wip

Author: heiytor

api/services/auth.go

@@ -101,7 +101,7 @@ func (s *service) AuthLocalUser(ctx context.Context, req *requests.AuthLocalUser
 		return nil, lockout, "", NewErrAuthUnathorized(nil)
 	}
 
-	if !hash.CompareWith(req.Password, user.Password) {
+	if !hash.CompareWith(req.Password, user.PasswordDigest) {
 		lockout, _, err := s.cache.StoreLoginAttempt(ctx, sourceIP, user.ID)
 		if err != nil {
 			log.WithError(err).
@@ -158,16 +158,14 @@ func (s *service) AuthLocalUser(ctx context.Context, req *requests.AuthLocalUser
 		return nil, 0, "", NewErrTokenSigned(err)
 	}
 
-	// Updates last_login and the hash algorithm to bcrypt if still using SHA256
-	changes := &models.UserChanges{LastLogin: clock.Now(), PreferredNamespace: &tenantID}
-	if !strings.HasPrefix(user.Password, "$") {
-		if neo, _ := models.HashUserPassword(req.Password); neo.Hash != "" {
-			changes.Password = neo.Hash
+	user.LastLogin = clock.Now()
+	if !strings.HasPrefix(user.PasswordDigest, "$") {
+		if digest, _ := hash.Do(req.Password); digest != "" {
+			user.PasswordDigest = digest
 		}
 	}
 
-	// TODO: evaluate make this update in a go routine.
-	if err := s.store.UserUpdate(ctx, user.ID, changes); err != nil {
+	if err := s.store.Save(ctx, user); err != nil {
 		return nil, 0, "", NewErrUserUpdate(user, err)
 	}
 
@@ -184,12 +182,12 @@ func (s *service) AuthLocalUser(ctx context.Context, req *requests.AuthLocalUser
 		User:          user.Username,
 		Name:          user.Name,
 		Email:         user.Email,
-		RecoveryEmail: user.RecoveryEmail,
+		RecoveryEmail: user.Preferences.SecurityEmail,
 		MFA:           user.MFA.Enabled,
 		Tenant:        tenantID,
 		Role:          role,
 		Token:         token,
-		MaxNamespaces: user.MaxNamespaces,
+		MaxNamespaces: user.Preferences.MaxNamespaces,
 	}
 
 	return res, 0, "", nil

api/services/namespace.go

@@ -32,15 +32,15 @@ func (s *service) CreateNamespace(ctx context.Context, req *requests.NamespaceCr
 
 	// When MaxNamespaces is less than zero, it means that the user has no limit
 	// of namespaces. If the value is zero, it means he has no right to create a new namespace
-	if user.MaxNamespaces == 0 {
-		return nil, NewErrNamespaceCreationIsForbidden(user.MaxNamespaces, nil)
-	} else if user.MaxNamespaces > 0 {
+	if user.Preferences.MaxNamespaces == 0 {
+		return nil, NewErrNamespaceCreationIsForbidden(user.Preferences.MaxNamespaces, nil)
+	} else if user.Preferences.MaxNamespaces > 0 {
 		info, err := s.store.UserGetInfo(ctx, req.UserID)
 		switch {
 		case err != nil:
 			return nil, err
-		case len(info.OwnedNamespaces) >= user.MaxNamespaces:
-			return nil, NewErrNamespaceLimitReached(user.MaxNamespaces, nil)
+		case len(info.OwnedNamespaces) >= user.Preferences.MaxNamespaces:
+			return nil, NewErrNamespaceLimitReached(user.Preferences.MaxNamespaces, nil)
 		}
 	}
 

api/store/mongo/store.go

@@ -69,3 +69,7 @@ func NewStore(ctx context.Context, uri string, cache cache.Cache, opts ...option
 
 	return store, nil
 }
+
+func (s *Store) Save(_ context.Context, _ any) error {
+	return nil
+}

api/store/pg/pg.go

@@ -51,3 +51,8 @@ func New(ctx context.Context, uri string, opts ...options.Option) (store.Store,
 
 	return pg, nil
 }
+
+func (pg *pg) Save(ctx context.Context, model any) error {
+	_, err := pg.driver.NewUpdate().Model(model).WherePK().Exec(ctx)
+	return fromSqlError(err)
+}

api/store/store.go

@@ -1,5 +1,7 @@
 package store
 
+import "context"
+
 //go:generate mockery --name Store --filename store.go
 type Store interface {
 	TagsStore
@@ -17,4 +19,6 @@ type Store interface {
 	SystemStore
 
 	Options() QueryOptions
+
+	Save(context.Context, any) error
 }

cli/services/users.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/shellhub-io/shellhub/cli/pkg/inputs"
+	"github.com/shellhub-io/shellhub/pkg/hash"
 	"github.com/shellhub-io/shellhub/pkg/models"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
@@ -30,23 +31,23 @@ func (s *service) UserCreate(ctx context.Context, input *inputs.UserCreate) (*mo
 		}
 	}
 
-	password, err := models.HashUserPassword(input.Password)
+	passwordDigest, err := hash.Do(input.Password)
 	if err != nil {
 		return nil, ErrUserPasswordInvalid
 	}
 
 	user := &models.User{
-		Origin:     models.UserOriginLocal,
-		ExternalID: "",
-		Status:     models.UserStatusConfirmed,
-		Name:       cases.Title(language.AmericanEnglish).String(strings.ToLower(input.Username)),
-		Email:      strings.ToLower(input.Email),
-		Username:   strings.ToLower(input.Username),
-		Password:   password.Hash,
+		Origin:         models.UserOriginLocal,
+		ExternalID:     "",
+		Status:         models.UserStatusConfirmed,
+		Name:           cases.Title(language.AmericanEnglish).String(strings.ToLower(input.Username)),
+		Email:          strings.ToLower(input.Email),
+		Username:       strings.ToLower(input.Username),
+		PasswordDigest: passwordDigest,
 		Preferences: models.UserPreferences{
 			PreferredNamespace: "",
 			AuthMethods:        []models.UserAuthMethod{models.UserAuthMethodLocal},
-			RecoveryEmail:      "",
+			SecurityEmail:      "",
 			MaxNamespaces:      -1,
 			EmailMarketing:     false,
 		},
@@ -105,17 +106,13 @@ func (s *service) UserUpdate(ctx context.Context, input *inputs.UserUpdate) erro
 		return ErrUserNotFound
 	}
 
-	password, err := models.HashUserPassword(input.Password)
+	passwordDigest, err := hash.Do(input.Password)
 	if err != nil {
 		return ErrUserPasswordInvalid
 	}
 
-	// TODO: validate this at cmd layer
-	if ok, err := s.validator.Struct(password); !ok || err != nil {
-		return ErrUserPasswordInvalid
-	}
-
-	if err := s.store.UserUpdate(ctx, user.ID, &models.UserChanges{Password: password.Hash}); err != nil {
+	user.PasswordDigest = passwordDigest
+	if err := s.store.Save(ctx, user); err != nil {
 		return ErrFailedUpdateUser
 	}
 

pkg/models/user.go

@@ -3,7 +3,6 @@ package models
 import (
 	"time"
 
-	"github.com/shellhub-io/shellhub/pkg/hash"
 	"github.com/shellhub-io/shellhub/pkg/validator"
 )
 
@@ -74,35 +73,21 @@ type User struct {
 
 	Status UserStatus `json:"status" bson:"status" bun:"status"`
 
-	Name     string `json:"name" validate:"required,name" bun:"name"`
-	Username string `json:"username" bson:"username" validate:"required,username" bun:"username"`
-	Email    string `json:"email" bson:"email" validate:"required,email" bun:"email"`
-	Password string `json:"-" bson:",inline" bun:"password_digest"`
+	Name           string `json:"name" validate:"required,name" bun:"name"`
+	Username       string `json:"username" bson:"username" validate:"required,username" bun:"username"`
+	Email          string `json:"email" bson:"email" validate:"required,email" bun:"email"`
+	PasswordDigest string `json:"-" bson:",inline" bun:"password_digest"`
 
 	Preferences UserPreferences `json:"preferences" bson:"preferences" bun:"embed:"`
-
-	///
-	///
-	///
-	///
-	///
-	///
-
-	MFA            UserMFA `json:"mfa" bson:"mfa" bun:"-"`
-	RecoveryEmail  string  `json:"recovery_email" bson:"recovery_email" validate:"omitempty,email" bun:"-"`
-	MaxNamespaces  int     `json:"max_namespaces" bson:"max_namespaces" bun:"-"`
-	EmailMarketing bool    `json:"email_marketing" bson:"email_marketing" bun:"-"`
+	MFA         UserMFA         `json:"mfa" bson:"mfa" bun:"-"`
 }
 
-type UserData struct {
-	Name     string `json:"name" validate:"required,name"`
-	Username string `json:"username" bson:"username" validate:"required,username"`
-	Email    string `json:"email" bson:"email" validate:"required,email"`
-	// RecoveryEmail is a custom, non-unique email address that a user can use to recover their account
-	// when they lose access to all other methods. It must never be equal to [UserData.Email].
-	//
-	// NOTE: Recovery email is available as a cloud-only feature and must be ignored in community.
-	RecoveryEmail string `json:"recovery_email" bson:"recovery_email" validate:"omitempty,email"`
+type UserPreferences struct {
+	PreferredNamespace string           `json:"-" bson:"preferred_namespace" bun:"preferred_namespace_id,nullzero"`
+	AuthMethods        []UserAuthMethod `json:"auth_methods" bson:"auth_methods" bun:"auth_methods,array"`
+	SecurityEmail      string           `json:"recovery_email" bson:"recovery_email" validate:"omitempty,email" bun:"security_email,nullzero"`
+	MaxNamespaces      int              `json:"max_namespaces" bson:"max_namespaces" bun:"namespace_ownership_limit"`
+	EmailMarketing     bool             `json:"email_marketing" bson:"email_marketing" bun:"email_marketing"`
 }
 
 // UserMFA represents the attributes related to MFA for a user.
@@ -115,43 +100,6 @@ type UserMFA struct {
 	RecoveryCodes []string `json:"-" bson:"recovery_codes"`
 }
 
-type UserPreferences struct {
-	PreferredNamespace string           `json:"-" bson:"preferred_namespace" bun:"preferred_namespace_id,nullzero"`
-	AuthMethods        []UserAuthMethod `json:"auth_methods" bson:"auth_methods" bun:"auth_methods,array"`
-	RecoveryEmail      string           `json:"recovery_email" bson:"recovery_email" validate:"omitempty,email" bun:"security_email,nullzero"`
-	MaxNamespaces      int              `json:"max_namespaces" bson:"max_namespaces" bun:"namespace_ownership_limit"`
-	EmailMarketing     bool             `json:"email_marketing" bson:"email_marketing" bun:"email_marketing"`
-}
-
-type UserPassword struct {
-	// Plain contains the plain text password.
-	Plain string `json:"password" bson:"-" validate:"required,password"`
-	// Hash contains the hashed pasword from plain text.
-	Hash string `json:"-" bson:"password"`
-}
-
-// HashUserPassword receives a plain password and hash it, returning
-// a [UserPassword].
-func HashUserPassword(plain string) (UserPassword, error) {
-	p := UserPassword{
-		Plain: plain,
-	}
-
-	var err error
-	p.Hash, err = hash.Do(p.Plain)
-
-	return p, err
-}
-
-// Compare reports whether a plain password matches with hash.
-//
-// For compatibility purposes, it can compare using both SHA256 and bcrypt algorithms.
-// Hashes starting with "$" are assumed to be a bcrypt hash; otherwise, they are treated as
-// SHA256 hashes.
-func (p *UserPassword) Compare(plain string) bool {
-	return hash.CompareWith(plain, p.Hash)
-}
-
 // UserAuthIdentifier is an username or email used to authenticate.
 type UserAuthIdentifier string
 

pkg/uuid/uuid.go

@@ -26,5 +26,6 @@ type goUUID struct{}
 
 // This function is responsible for generating UUID v4 of the google package.
 func (g *goUUID) Generate() string {
-	return uuid.NewString()
+	u, _ := uuid.NewV7()
+	return u.String()
 }