func TestHashStorage(t *testing.T) { Verbose = true //host := New() // locally host := NewHost("travis:@127.0.0.1/") // for travis-ci //host := NewHost("go:go@/main") // laptop defer host.Close() hashmap, err := NewHashMap(host, hashmapname) if err != nil { t.Error(err) } hashmap.Clear() username := "******" key := "password" password := "******" // bcrypt test passwordHash, _ := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost) value := string(passwordHash) if err := hashmap.Set(username, key, value); err != nil { t.Errorf("Error, could not set value in hashmap! %s", err.Error()) } item, err := hashmap.Get(username, key) if err != nil { t.Errorf("Unable to retrieve from hashmap! %s\n", err.Error()) } if item != value { t.Errorf("Error, got a different value back (bcrypt)! %s != %s\n", value, item) } // sha256 test hasher := sha256.New() io.WriteString(hasher, password+cookie.RandomCookieFriendlyString(30)+username) passwordHash = hasher.Sum(nil) value = string(passwordHash) if err := hashmap.Set(username, key, value); err != nil { t.Errorf("Error, could not set value in hashmap! %s", err.Error()) } item, err = hashmap.Get(username, key) if err != nil { t.Errorf("Unable to retrieve from hashmap! %s\n", err.Error()) } if item != value { t.Errorf("Error, got a different value back (sha256)! %s != %s\n", value, item) } err = hashmap.Remove() if err != nil { t.Errorf("Error, could not remove hashmap! %s", err.Error()) } }
// Create a new *UserState that can be used for managing users. // dbindex is the Redis database index (0 is a good default value). // If randomseed is true, the random number generator will be seeded after generating the cookie secret (true is a good default value). // redisHostPort is host:port for the desired Redis server (can be blank for localhost) // Also creates a new ConnectionPool. func NewUserState(dbindex int, randomseed bool, redisHostPort string) *UserState { var pool *simpleredis.ConnectionPool // Connnect to the default redis server if redisHostPort is empty if redisHostPort == "" { redisHostPort = defaultRedisServer } // Test connection if err := simpleredis.TestConnectionHost(redisHostPort); err != nil { log.Fatalln(err.Error()) } // Aquire connection pool pool = simpleredis.NewConnectionPoolHost(redisHostPort) state := new(UserState) state.users = simpleredis.NewHashMap(pool, "users") state.users.SelectDatabase(dbindex) state.usernames = simpleredis.NewSet(pool, "usernames") state.usernames.SelectDatabase(dbindex) state.unconfirmed = simpleredis.NewSet(pool, "unconfirmed") state.unconfirmed.SelectDatabase(dbindex) state.pool = pool state.dbindex = dbindex // For the secure cookies // This must happen before the random seeding, or // else people will have to log in again after every server restart state.cookieSecret = cookie.RandomCookieFriendlyString(30) // Seed the random number generator if randomseed { rand.Seed(time.Now().UnixNano()) } // Cookies lasts for 24 hours by default. Specified in seconds. state.cookieTime = cookie.DefaultCookieTime // Default password hashing algorithm is "bcrypt+", which is the same as // "bcrypt", but with backwards compatibility for checking sha256 hashes. state.passwordAlgorithm = "bcrypt+" // "bcrypt+", "bcrypt" or "sha256" if pool.Ping() != nil { defer pool.Close() log.Fatalf("Error, wrong hostname, port or password. (%s does not reply to PING)\n", redisHostPort) } return state }
// Create a new *UserState that can be used for managing users. // connectionString may be on the form "username:password@host:port/database". // If randomSeed is true, the random number generator will be seeded after generating the cookie secret (true is a good default value). func NewUserState(connectionString string, randomSeed bool) (*UserState, error) { // Test connection if err := db.TestConnectionHost(connectionString); err != nil { return nil, err } host := db.NewHost(connectionString) state := new(UserState) var err error state.users, err = db.NewHashMap(host, "users") if err != nil { return nil, err } state.usernames, err = db.NewSet(host, "usernames") if err != nil { return nil, err } state.unconfirmed, err = db.NewSet(host, "unconfirmed") if err != nil { return nil, err } state.host = host // For the secure cookies // This must happen before the random seeding, or // else people will have to log in again after every server restart state.cookieSecret = cookie.RandomCookieFriendlyString(30) // Seed the random number generator if randomSeed { rand.Seed(time.Now().UnixNano()) } // Cookies lasts for 24 hours by default. Specified in seconds. state.cookieTime = 3600 * 24 // Default password hashing algorithm is "bcrypt+", which is the same as // "bcrypt", but with backwards compatibility for checking sha256 hashes. state.passwordAlgorithm = "bcrypt+" // "bcrypt+", "bcrypt" or "sha256" if err := host.Ping(); err != nil { defer host.Close() return nil, fmt.Errorf("Error when pinging %s: %s\n", connectionString, err.Error()) } return state, nil }
// Create a new *UserState that can be used for managing users. // connectionString may be on the form "username:password@host:port/database". // If randomseed is true, the random number generator will be seeded after generating the cookie secret (true is a good default value). func NewUserState(filename string, randomseed bool) (*UserState, error) { var err error db, err := simplebolt.New(filename) if err != nil { return nil, err } state := new(UserState) state.users, err = simplebolt.NewHashMap(db, "users") if err != nil { return nil, err } state.usernames, err = simplebolt.NewSet(db, "usernames") if err != nil { return nil, err } state.unconfirmed, err = simplebolt.NewSet(db, "unconfirmed") if err != nil { return nil, err } state.db = db // For the secure cookies // This must happen before the random seeding, or // else people will have to log in again after every server restart state.cookieSecret = cookie.RandomCookieFriendlyString(30) // Seed the random number generator if randomseed { rand.Seed(time.Now().UnixNano()) } // Cookies lasts for 24 hours by default. Specified in seconds. state.cookieTime = 3600 * 24 // Default password hashing algorithm is "bcrypt+", which is the same as // "bcrypt", but with backwards compatibility for checking sha256 hashes. state.passwordAlgorithm = "bcrypt+" // "bcrypt+", "bcrypt" or "sha256" return state, nil }