func init() { a := []byte(os.Getenv("GOTHIC_COOKIE_AUTH")) if len(a) == 0 { a = securecookie.GenerateRandomKey(64) } e := []byte(os.Getenv("GOTHIC_COOKIE_ENCRYPT")) if len(e) == 0 { codecs = securecookie.CodecsFromPairs(a) } else { codecs = securecookie.CodecsFromPairs(a, e) } }
func NewPGStore(dbUrl string, keyPairs ...[]byte) *PGStore { db, err := sql.Open("postgres", dbUrl) dbmap := &gorp.DbMap{Db: db, Dialect: gorp.PostgresDialect{}} dbStore := &PGStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, DbMap: dbmap, } if err != nil { // Ignore and return nil return nil } // Create table if it doesn't exist dbmap.AddTableWithName(Session{}, "http_sessions").SetKeys(true, "Id") err = dbmap.CreateTablesIfNotExists() if err != nil { // Ignore and return nil return nil } return dbStore }
func init() { godotenv.Load() redisClient = storage.RedisClient(os.Getenv("REDIS_ADDR"), os.Getenv("REDIS_PASS")) translator = t.NewTranslateAdapter( []backend_full.IBackendFull{ backend_full.NewGoogleTranslator(httpclient.GetHttpClient(), os.Getenv("G_TR_KEY")), backend_full.NewYandexTranslator(httpclient.GetHttpClient(), os.Getenv("Y_TR_KEY")), // backend_full.NewBingTranslator(os.Getenv("B_TR_KEY")), }, components.NewChain(2), ) //translator.AddParticular(&particular.AbbyyLingvoLiveTranslator{}) if "" == os.Getenv("APP_SECRET") { os.Setenv("APP_SECRET", string(securecookie.GenerateRandomKey(32))) } cookieStore = &sessions.CookieStore{ Codecs: securecookie.CodecsFromPairs([]byte(os.Getenv("APP_SECRET"))), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30 * 10, // Secure:true, HttpOnly: true, }, } }
// NewRediStore returns a new RediStore. func NewRediStore(size int, network, address, password string, keyPairs ...[]byte) *RediStore { return &RediStore{ // http://godoc.org/github.com/garyburd/redigo/redis#Pool Pool: &redis.Pool{ MaxIdle: size, IdleTimeout: 240 * time.Second, Dial: func() (redis.Conn, error) { c, err := redis.Dial(network, address) if err != nil { return nil, err } if password != "" { if _, err := c.Do("AUTH", password); err != nil { c.Close() return nil, err } } return c, err }, TestOnBorrow: func(c redis.Conn, t time.Time) error { _, err := c.Do("PING") return err }, }, Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: sessionExpire, }, } }
func SessionCookieFilter(cookieName string, opts *CookieOpts, keyPairs ...[]byte) restful.FilterFunction { codecs := securecookie.CodecsFromPairs(keyPairs...) return func(req *restful.Request, resp *restful.Response, chain *restful.FilterChain) { session := NewSession() if cookie, err := req.Request.Cookie(cookieName); err == nil { if err = securecookie.DecodeMulti(cookieName, cookie.Value, &session.store, codecs...); err == nil { } else { logrus.Warn(err) } } else { if err != http.ErrNoCookie { logrus.Warn(err) } } req.SetAttribute(AttrSessionKey, session) // I don't know how to write cookie in restful, so I use underneath negroni before hook resp.ResponseWriter.(negroni.ResponseWriter).Before(func(rw negroni.ResponseWriter) { if !session.IsModified() { return } if encoded, err := securecookie.EncodeMulti(cookieName, session.store, codecs...); err == nil { cookie := NewCookie(cookieName, encoded, opts) http.SetCookie(rw, cookie) } }) chain.ProcessFilter(req, resp) } }
// This function returns a new Redis Sentinel store. // // Keys are defined in pairs to allow key rotation, but the common case is // to set a single authentication key and optionally an encryption key. // // The first key in a pair is used for authentication and the second for // encryption. The encryption key can be set to nil or omitted in the last // pair, but the authentication key is required in all pairs. // // It is recommended to use an authentication key with 32 or 64 bytes. // The encryption key, if set, must be either 16, 24, or 32 bytes to select // AES-128, AES-192, or AES-256 modes. // // Use the convenience function securecookie.GenerateRandomKey() to create // strong keys. func NewSentinelFailoverStore(clientConfig SentinelClientConfig, keyPairs ...[]byte) *SentinelFailoverStore { client := clientConfig.newSentinelFailoverClient() s := &SentinelFailoverStore{ RediStore: &redistore.RediStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, DefaultMaxAge: 60 * 60, // 60 minutes //maxLength: 4096, //keyPrefix: "session_", //serializer: redistore.GobSerializer{}, }, failoverOption: clientConfig, FailoverClient: client, maxLength: 4096, keyPrefix: "session_", serializer: redistore.GobSerializer{}, } s.SetMaxLength(s.maxLength) s.SetKeyPrefix(s.keyPrefix) s.SetSerializer(s.serializer) s.MaxAge(s.Options.MaxAge) return s }
// New is returns a store object using the provided dal.Connection func New(connection dal.Connection, database string, collection string, maxAge int, ensureTTL bool, keyPairs ...[]byte) nSessions.Store { if ensureTTL { conn := connection.Clone() defer conn.Close() db := conn.DB(database) c := db.C(collection) c.EnsureIndex(dal.Index{ Key: []string{"modified"}, Background: true, Sparse: true, ExpireAfter: time.Duration(maxAge) * time.Second, }) } return &dalStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Token: nSessions.NewCookieToken(), connection: connection, database: database, collection: collection, options: &gSessions.Options{ MaxAge: maxAge, }, } }
// NewCookieStore returns a new CookieStore. // // Keys are defined in pairs to allow key rotation, but the common case is // to set a single authentication key and optionally an encryption key. // // The first key in a pair is used for authentication and the second for // encryption. The encryption key can be set to nil or omitted in the last // pair, but the authentication key is required in all pairs. // // It is recommended to use an authentication key with 32 or 64 bytes. // The encryption key, if set, must be either 16, 24, or 32 bytes to select // AES-128, AES-192, or AES-256 modes. // // Use the convenience function securecookie.GenerateRandomKey() to create // strong keys. func NewCookieStore(keyPairs ...[]byte) *CookieStore { return &CookieStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &Options{ Path: "/", MaxAge: 86400 * 30, }, } }
// NewPGStore initillizes PGStore with the given keyPairs func NewPGStore(keyPairs ...[]byte) *PGStore { dbStore := &PGStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: settings.App.Session.Path, MaxAge: settings.App.Session.MaxAge, }, } return dbStore }
func (h *RedisStoreHandler) GetSessionStore() sessions.Store { return &RedisStore{ Codecs: securecookie.CodecsFromPairs(h.keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, storeHandler: h, } }
func NewSqliteStoreFromConnection(db *sql.DB, tableName string, path string, maxAge int, keyPairs ...[]byte) (*SqliteStore, error) { // Make sure table name is enclosed. tableName = "`" + strings.Trim(tableName, "`") + "`" cTableQ := "CREATE TABLE IF NOT EXISTS " + tableName + " (id INTEGER PRIMARY KEY, " + "session_data LONGBLOB, " + "created_on TIMESTAMP DEFAULT 0, " + "modified_on TIMESTAMP DEFAULT CURRENT_TIMESTAMP, " + "expires_on TIMESTAMP DEFAULT 0);" if _, err := db.Exec(cTableQ); err != nil { return nil, err } insQ := "INSERT INTO " + tableName + "(id, session_data, created_on, modified_on, expires_on) VALUES (NULL, ?, ?, ?, ?)" stmtInsert, stmtErr := db.Prepare(insQ) if stmtErr != nil { return nil, stmtErr } delQ := "DELETE FROM " + tableName + " WHERE id = ?" stmtDelete, stmtErr := db.Prepare(delQ) if stmtErr != nil { return nil, stmtErr } updQ := "UPDATE " + tableName + " SET session_data = ?, created_on = ?, expires_on = ? " + "WHERE id = ?" stmtUpdate, stmtErr := db.Prepare(updQ) if stmtErr != nil { return nil, stmtErr } selQ := "SELECT id, session_data, created_on, modified_on, expires_on from " + tableName + " WHERE id = ?" stmtSelect, stmtErr := db.Prepare(selQ) if stmtErr != nil { return nil, stmtErr } return &SqliteStore{ db: db, stmtInsert: stmtInsert, stmtDelete: stmtDelete, stmtUpdate: stmtUpdate, stmtSelect: stmtSelect, Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: path, MaxAge: maxAge, }, table: tableName, }, nil }
func NewRethinkDBStore(rethinkdbSession *gorethink.Session, db, table string, keyPairs ...[]byte) *RethinkDBStore { return &RethinkDBStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, term: gorethink.Db(db).Table(table), rethinkdbSession: rethinkdbSession, } }
func NewDatabaseStore(keyPairs ...[]byte) *DatabaseStore { dbStore := &DatabaseStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, } return dbStore }
// NewSessionStore returns a new DbStore. // // The path argument is the directory where sessions will be saved. If empty // it will use os.TempDir(). // // See NewCookieStore() for a description of the other parameters. func NewDbStore(age int) *DbStore { sessionStore := &DbStore{ Codecs: securecookie.CodecsFromPairs([]byte("secret")), Options: &Options{ Path: "/", MaxAge: age, //seconds }, } go sessionStore.CheckDbSessions() return sessionStore }
// NewRedisStore returns a new RedisStore func NewRedisStore(pool *redis.Pool, keyPairs ...[]byte) *RedisStore { return &RedisStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, redisPool: pool, } }
func NewMemoryStore(age int) *MemoryStore { memoryStore := &MemoryStore{ Codecs: securecookie.CodecsFromPairs([]byte("secret")), Options: &sessions.Options{ Path: "/", MaxAge: age, //default 30 minutes }, Container: make(map[string]*SessionInfo), } go memoryStore.CheckMemorySessions() return memoryStore }
// Sessions implemented with a dumb in-memory // map and no expiration. Good for local // development so you don't have to run // memcached on your laptop just to fire up // your app and hack away. func NewDumbMemorySessionStore() *DumbMemoryStore { keyPair := []byte("stub") return &DumbMemoryStore{ Codecs: securecookie.CodecsFromPairs(keyPair), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, Data: make(map[string]string), } }
// NewFilesystemStore returns a new FilesystemStore. // // The path argument is the directory where sessions will be saved. If empty // it will use os.TempDir(). // // See NewCookieStore() for a description of the other parameters. func NewFilesystemStore(path string, keyPairs ...[]byte) *FilesystemStore { if path == "" { path = os.TempDir() } return &FilesystemStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &Options{ Path: "/", MaxAge: 86400 * 30, }, path: path, } }
// New returns a new session store. // See https://github.com/gorilla/sessions/blob/master/store.go for what keyPairs means. // Especially for dynamostore, keyPairs is be used to authenticate session id. // Yes, the actual data is stored in DynamoDB table. func New(dynamodbAPI dynamodbiface.DynamoDBAPI, tableName string, keyPairs ...[]byte) *Store { // setting DynamoDB table wrapper t := table.New(dynamodbAPI, tableName).WithHashKey(SessionIdHashKeyName, "S") s := &Store{ Table: t, Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: DefaultSessionOpts, } s.MaxAge(s.Options.MaxAge) return s }
// 新建cookie存储仓 func newCookieStore(keyPairs ...[]byte) *sessions.CookieStore { cs := &sessions.CookieStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 0, // 只存为会话,关闭则失效 HttpOnly: true, }, } cs.MaxAge(cs.Options.MaxAge) return cs }
// NewDatastoreStore returns a new DatastoreStore. // // The kind argument is the kind name used to store the session data. // If empty it will use "Session". // // See NewCookieStore() for a description of the other parameters. func NewDatastoreStore(kind string, nonPersistentSessionDuration time.Duration, keyPairs ...[]byte) *DatastoreStore { if kind == "" { kind = "Session" } return &DatastoreStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, kind: kind, nonPersistentSessionDuration: nonPersistentSessionDuration, } }
// NewMemcacheStore returns a new MemcacheStore. // // The keyPrefix argument is the prefix used for memcache keys. If empty it // will use "gorilla.appengine.sessions.". // // See NewCookieStore() for a description of the other parameters. func NewMemcacheStore(keyPrefix string, nonPersistentSessionDuration time.Duration, keyPairs ...[]byte) *MemcacheStore { if keyPrefix == "" { keyPrefix = "gorilla.appengine.sessions." } return &MemcacheStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, prefix: keyPrefix, nonPersistentSessionDuration: nonPersistentSessionDuration, } }
func NewLevelDBStore(path string) (LevelDBStore, error) { ldb, err := leveldb.OpenFile(path, nil) if err != nil { return nil, err } return &leveldbStore{ db: ldb, options: &sessions.Options{ Path: "/", MaxAge: sessionExpire, }, Codecs: securecookie.CodecsFromPairs([]byte("b80cbe50-6e0d-4dec-ad30-c3480ff79292")), }, nil }
// NewRediStoreWithPool instantiates a RediStore with a *redis.Pool passed in. func NewRediStoreWithPool(pool *redis.Pool, keyPairs ...[]byte) (*RediStore, error) { rs := &RediStore{ // http://godoc.org/github.com/garyburd/redigo/redis#Pool Pool: pool, Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: sessionExpire, }, DefaultMaxAge: 60 * 20, // 20 minutes seems like a reasonable default maxLength: 4096, } _, err := rs.ping() return rs, err }
// NewStore creates a new *Store instance. func NewStore(db *gorm.DB, config *Config, keyPairs ...[]byte) *Store { q := &query{} q.DB = db return &Store{ q: q, codecs: securecookie.CodecsFromPairs(keyPairs...), options: &sessions.Options{ Path: config.SessionPath, Domain: config.SessionDomain, MaxAge: config.SessionMaxAge, Secure: config.SessionSecure, HttpOnly: config.SessionHTTPOnly, }, } }
// New creates and returns a session store. func New(db *bolt.DB, config Config, keyPairs ...[]byte) (*Store, error) { config.setDefault() store := &Store{ codecs: securecookie.CodecsFromPairs(keyPairs...), config: config, db: db, } err := db.Update(func(tx *bolt.Tx) error { _, err := tx.CreateBucketIfNotExists(config.DBOptions.BucketName) return err }) if err != nil { return nil, err } return store, nil }
func NewDynamoStoreWithRegionObj(accessKey string, secretKey string, tableName string, region aws.Region, keyPairs ...[]byte) (*DynamoStore, error) { awsAuth := aws.Auth{ AccessKey: accessKey, SecretKey: secretKey, } server := dynamodb.New(awsAuth, region) table := server.NewTable(tableName, dynamodb.PrimaryKey{KeyAttribute: dynamodb.NewStringAttribute("Id", "")}) dynStore := &DynamoStore{ Table: table, Codecs: securecookie.CodecsFromPairs(keyPairs...), } return dynStore, nil }
// NewMemcacheStore returns a new MemcacheStore. // You need to provide the memcache client and // an optional prefix for the keys we store func NewMemcacheStore(client *memcache.Client, keyPrefix string, keyPairs ...[]byte) *MemcacheStore { if client == nil { panic("Cannot have nil memcache client") } return &MemcacheStore{ Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: 86400 * 30, }, KeyPrefix: keyPrefix, Client: client, StoreMethod: StoreMethodSecureCookie, } }
// NewSessionStore returns a new FileStore. // // The path argument is the directory where sessions will be saved. If empty // it will use os.TempDir(). // // See NewCookieStore() for a description of the other parameters. func NewFileStore(age int) *FileStore { path := "." if path[len(path)-1] != '/' { path += "/" } sessionStore := &FileStore{ Codecs: securecookie.CodecsFromPairs([]byte("secret")), Options: &Options{ Path: "/", // MaxAge: 86400 * 30, MaxAge: age, //30 minutes }, path: path, } go sessionStore.CheckFileSessions() return sessionStore }
// NewRethinkStore returns a new RethinkStore. // // Takes in the database address, database name, session table, // max idle connections, max open connections, and session key pairs. func NewRethinkStore(addr, db, table string, idle, open int, keyPairs ...[]byte) (*RethinkStore, error) { session, err := r.Connect(r.ConnectOpts{ Address: addr, Database: db, MaxIdle: idle, MaxOpen: open, }) if err != nil { return nil, err } return &RethinkStore{ Rethink: session, Table: table, Codecs: securecookie.CodecsFromPairs(keyPairs...), Options: &sessions.Options{ Path: "/", MaxAge: sessionExpire, }, }, nil }