refactor: harden authentication and file access security

Author: bclswl0827

internal/dao/action/sys_users.go

@@ -97,14 +97,17 @@ func (h *Handler) SysUserCreate(username, password string, isAdmin bool) (string
 		IsAdmin:  strconv.FormatBool(isAdmin),
 		Username: username,
 	}
-	user.HashedPassword = user.GetHashedPassword(password)
+	hashedPassword, err := user.GetHashedPassword(password)
+	if err != nil {
+		return "", fmt.Errorf("failed to encode password: %w", err)
+	}
+	user.HashedPassword = hashedPassword
 	user.UserId = user.NewUserId()
 
-	err := h.daoObj.Database.
+	if err = h.daoObj.Database.
 		Table(user.GetName(h.daoObj.GetPrefix())).
 		Save(&user).
-		Error
-	if err != nil {
+		Error; err != nil {
 		return "", fmt.Errorf("failed to create user: %w", err)
 	}
 

internal/dao/model/sys_users.go

@@ -52,9 +52,9 @@ func (t *SysUser) NewUserId() string {
 	return id.Generate().String()
 }
 
-func (t *SysUser) GetHashedPassword(password string) string {
-	hashedPassword, _ := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
-	return string(hashedPassword)
+func (t *SysUser) GetHashedPassword(password string) (string, error) {
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	return string(hashedPassword), err
 }
 
 func (t *SysUser) IsPasswordCorrect(password string) bool {

internal/server/middleware/auth_jwt/secret.go

@@ -1,64 +1,14 @@
 package auth_jwt
 
 import (
-	"errors"
+	"crypto/rand"
 	"fmt"
-	"net"
-	"os"
-	"runtime"
-	"strings"
-
-	"github.com/anyshake/observer/pkg/system"
-	"github.com/google/uuid"
-	"github.com/samber/lo"
-	"github.com/shirou/gopsutil/v4/disk"
-	"github.com/shirou/gopsutil/v4/mem"
 )
 
 func createJwtSecret() ([]byte, error) {
-	if interfaces, err := net.Interfaces(); len(interfaces) > 0 && err == nil {
-		macAddrArr := lo.FilterMap(interfaces, func(iface net.Interface, _ int) (string, bool) {
-			if iface.Flags&net.FlagLoopback != 0 || len(iface.HardwareAddr) == 0 {
-				return "", false
-			}
-			return iface.HardwareAddr.String(), true
-		})
-		if len(macAddrArr) > 0 {
-			secret := uuid.NewSHA1(uuid.NameSpaceOID, []byte(strings.Join(macAddrArr, ";"))).String()
-			return []byte(secret), nil
-		}
-	}
-
-	if hostname, err := os.Hostname(); len(hostname) > 0 && err == nil {
-		cpuModel, err := system.GetCpuModel()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get CPU model when creating JWT secret: %w", err)
-		}
-		memUsage, err := mem.VirtualMemory()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get memory usage when creating JWT secret: %w", err)
-		}
-		cwd, err := os.Getwd()
-		if err != nil {
-			return nil, fmt.Errorf("failed to get current executable path when creating JWT secret: %w", err)
-		}
-		diskObj, err := disk.Usage(cwd)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get disk usage when creating JWT secret: %w", err)
-		}
-		secretSeed := fmt.Sprintf(
-			"%s/%s on %s, CPU model %s, RAM size %d bytes, disk size %d bytes, current run path %s",
-			runtime.GOOS,
-			runtime.GOARCH,
-			hostname,
-			cpuModel,
-			memUsage.Total,
-			diskObj.Total,
-			cwd,
-		)
-		secret := uuid.NewSHA1(uuid.NameSpaceOID, []byte(secretSeed)).String()
-		return []byte(secret), nil
+	secret := make([]byte, 32)
+	if _, err := rand.Read(secret); err != nil {
+		return nil, fmt.Errorf("failed to generate random JWT secret: %w", err)
 	}
-
-	return nil, errors.New("no suitable secret seed found")
+	return secret, nil
 }

internal/server/router/auth/challenge.go

@@ -2,7 +2,12 @@ package auth
 
 import (
 	"crypto/rand"
+	"crypto/sha512"
+	"crypto/subtle"
+	"encoding/hex"
 	"math/big"
+	"strconv"
+	"strings"
 	"time"
 )
 
@@ -33,8 +38,14 @@ func (la *authChallenge) getChallengeId() string {
 		length = 20
 	)
 	b := make([]byte, length)
-	for i := 0; i < length; i++ {
-		n, _ := rand.Int(rand.Reader, big.NewInt(int64(len(chars))))
+	for i := range length {
+		n, err := rand.Int(rand.Reader, big.NewInt(int64(len(chars))))
+		if err != nil {
+			var rb [1]byte
+			_, _ = rand.Read(rb[:])
+			b[i] = chars[int(rb[0])%len(chars)]
+			continue
+		}
 		b[i] = chars[n.Int64()]
 	}
 
@@ -45,12 +56,42 @@ func (la *authChallenge) isChallengeAlive() bool {
 	return time.Now().Before(la.createdAt.Add(la.ttl))
 }
 
-func (la *authChallenge) verifyChallenge(id, solution string) bool {
-	for i := byte(0); i < la.seed[0]; i++ {
-		if solution[i] != '0' {
-			return false
-		}
+func (la *authChallenge) verifyChallenge(solution string) bool {
+	if len(la.seed) < 2 {
+		return false
+	}
+
+	difficulty := int(la.seed[0])
+	if difficulty < 0 || difficulty > hex.EncodedLen(sha512.Size) {
+		return false
+	}
+
+	nonceStr, hashHex, ok := strings.Cut(solution, ":")
+	if !ok || nonceStr == "" || hashHex == "" {
+		return false
+	}
+	if _, err := strconv.ParseUint(nonceStr, 10, 64); err != nil {
+		return false
+	}
+
+	expected, err := hex.DecodeString(hashHex)
+	if err != nil || len(expected) != sha512.Size {
+		return false
+	}
+
+	challenge := la.seed[1:]
+	var textBuilder strings.Builder
+	textBuilder.Grow(len(challenge) + len(nonceStr))
+	for _, b := range challenge {
+		textBuilder.WriteRune(rune(b))
+	}
+	textBuilder.WriteString(nonceStr)
+
+	sum := sha512.Sum512([]byte(textBuilder.String()))
+	if subtle.ConstantTimeCompare(expected, sum[:]) != 1 {
+		return false
 	}
 
-	return true
+	actualHex := hex.EncodeToString(sum[:])
+	return strings.HasPrefix(actualHex, strings.Repeat("0", difficulty))
 }

internal/server/router/auth/login.go

@@ -4,95 +4,112 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"net/http"
 	"time"
 
+	"github.com/anyshake/observer/pkg/logger"
 	"github.com/dchest/captcha"
 )
 
+var (
+	errInvalidLoginRequest = errors.New("invalid login request")
+	errAuthenticationFailed = errors.New("authentication failed")
+)
+
 func (h *auth) login(sessionId, secret, nonce, challengeId, challengeSolution, captchaId, captchaVal, payload, userAgent, userIp string) (code int, userId string, err error) {
+	fail := func(status int, public error, internal string, args ...any) (int, string, error) {
+		if internal != "" {
+			logger.GetLogger(LOG_PREFIX).Errorf(internal, args...)
+		}
+		return status, "", public
+	}
+
 	if sessionId == "" || secret == "" || nonce == "" || challengeId == "" || challengeSolution == "" || captchaId == "" || captchaVal == "" || payload == "" {
-		return http.StatusBadRequest, "", errors.New("failed to login: missing required fields in request")
+		return fail(http.StatusBadRequest, errInvalidLoginRequest, "login rejected: missing required fields")
 	}
 
 	// 1. Check if the nonce is valid and not reused
 	nc, err := base64.StdEncoding.DecodeString(nonce)
 	if err != nil {
-		return http.StatusBadRequest, "", errors.New("failed to login: provided nonce is invalid")
+		return fail(http.StatusBadRequest, errInvalidLoginRequest, "login rejected: invalid nonce encoding: %v", err)
 	}
 	ncStr := string(nc)
 	if t, ok := h.nonceCache.Get(ncStr); ok && time.Since(t) <= time.Hour {
-		return http.StatusForbidden, "", errors.New("failed to login: replay attack detected")
+		return fail(http.StatusForbidden, errAuthenticationFailed, "login rejected: nonce replay detected")
 	}
 	h.nonceCache.Add(ncStr, time.Now())
 
 	// 2. Verify PoW challenge solution
 	challenge, ok := h.authChallengePool.GetAndDel(challengeId)
 	if !ok {
-		return http.StatusUnauthorized, "", errors.New("failed to login: invalid pre-auth challenge ID")
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: unknown challenge id")
 	}
 	if !challenge.isChallengeAlive() {
-		return http.StatusUnauthorized, "", errors.New("failed to login: pre-auth challenge has expired, please try again")
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: challenge expired")
 	}
-	if !challenge.verifyChallenge(challengeId, challengeSolution) {
-		return http.StatusUnauthorized, "", errors.New("failed to login: invalid challenge solution")
+	if !challenge.verifyChallenge(challengeSolution) {
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: invalid PoW solution")
 	}
 
 	// 3. Verify captcha solution
 	if !captcha.VerifyString(captchaId, captchaVal) {
-		return http.StatusUnauthorized, "", fmt.Errorf("failed to login: provided captcha solution %s is invalid", captchaVal)
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: invalid captcha")
 	}
 
 	// 4. Extract RSA key pair from session ID
-	kp, ok := h.keyPairDataPool.GetAndDel(sessionId)
+	// Key pairs are shared across preauth requests within TTL, so do not delete on use.
+	kp, ok := h.keyPairDataPool.Get(sessionId)
 	if !ok {
-		return http.StatusUnauthorized, "", errors.New("failed to login: provided session ID is invalid")
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: unknown session id")
 	}
 	if !kp.isKeyPairAlive() {
-		return http.StatusUnauthorized, "", errors.New("failed to login: provided session ID has expired")
+		h.keyPairDataPool.Del(sessionId)
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: session expired")
 	}
 
 	// 5. Attempt to decrypt RSA encrypted AES secret from payload
 	aesSecretBytesB64, err := kp.rsaKeyPair.Decrypt([]byte(secret), true)
 	if err != nil {
-		return http.StatusUnauthorized, "", fmt.Errorf("failed to login: failed to decrypt secret: %w", err)
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: secret decrypt failed: %v", err)
 	}
 	aesSecretBytes, err := base64.StdEncoding.DecodeString(string(aesSecretBytesB64))
 	if err != nil {
-		return http.StatusUnauthorized, "", fmt.Errorf("failed to login: failed to decode secret: %w", err)
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: secret decode failed: %v", err)
 	}
 	encryptor := newAES256GCM(aesSecretBytes)
+	if encryptor == nil {
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: failed to init AES-GCM")
+	}
 
 	// 6. Additional check to ensure data integrity (defense in depth)
 	if _, err := encryptor.decrypt(nc, []byte(sessionId)); err != nil {
-		return http.StatusForbidden, "", fmt.Errorf("failed to login: malformed nonce received: %w", err)
+		return fail(http.StatusForbidden, errAuthenticationFailed, "login rejected: malformed nonce: %v", err)
 	}
 
 	// 7. Attempt to decrypt AES encrypted payload containing credential
 	pl, err := base64.StdEncoding.DecodeString(payload)
 	if err != nil {
-		return http.StatusBadRequest, "", errors.New("failed to login: provided payload is invalid")
+		return fail(http.StatusBadRequest, errInvalidLoginRequest, "login rejected: invalid payload encoding: %v", err)
 	}
 	credential, err := encryptor.decrypt(pl, []byte(sessionId))
 	if err != nil {
-		return http.StatusUnauthorized, "", fmt.Errorf("failed to login: failed to decrypt payload: %w", err)
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: payload decrypt failed: %v", err)
 	}
 
 	// 8. Unmarshal credential and perform login logic
 	var credentialMap map[string]any
 	if err = json.Unmarshal(credential, &credentialMap); err != nil {
-		return http.StatusUnauthorized, "", fmt.Errorf("failed to login: failed to unmarshal payload: %w", err)
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: credential unmarshal failed: %v", err)
 	}
 	username, usernameOk := credentialMap["username"].(string)
 	password, passwordOk := credentialMap["password"].(string)
 	if !usernameOk || !passwordOk {
-		return http.StatusUnauthorized, "", errors.New("failed to login: provided credential format is invalid")
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: credential format invalid")
 	}
 
 	userId, err = h.actionHandler.SysUserLogin(username, password, userAgent, userIp)
 	if err != nil {
-		return http.StatusUnauthorized, "", fmt.Errorf("user login failed: %w", err)
+		return fail(http.StatusUnauthorized, errAuthenticationFailed, "login rejected: user auth failed for %s: %v", username, err)
 	}
 
 	return http.StatusOK, userId, nil

internal/server/router/auth/preauth.go

@@ -3,20 +3,59 @@ package auth
 import (
 	"bytes"
 	"encoding/base64"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
 
 	"github.com/dchest/captcha"
 )
 
-func (h *auth) preAuth(ttl time.Duration) (code int, msg string, res any, err error) {
+func (h *auth) cleanupExpiredAuthState() {
+	for key, pair := range h.keyPairDataPool.Iterator() {
+		if !pair.isKeyPairAlive() {
+			h.keyPairDataPool.Del(key)
+		}
+	}
+	for key, attempt := range h.authChallengePool.Iterator() {
+		if !attempt.isChallengeAlive() {
+			h.authChallengePool.Del(key)
+		}
+	}
+}
+
+func (h *auth) getSharedKeyPair(ttl time.Duration) (*keyPair, error) {
+	h.keyPairMu.Lock()
+	defer h.keyPairMu.Unlock()
+
+	for key, pair := range h.keyPairDataPool.Iterator() {
+		if pair.isKeyPairAlive() {
+			return pair, nil
+		}
+		h.keyPairDataPool.Del(key)
+	}
+
 	kp, err := newKeyPair(ttl)
+	if err != nil {
+		return nil, err
+	}
+	h.keyPairDataPool.Set(kp.getKeyPairId(), kp)
+	return kp, nil
+}
+
+func (h *auth) preAuth(ttl time.Duration) (code int, msg string, res any, err error) {
+	h.cleanupExpiredAuthState()
+
+	if h.authChallengePool.Len() >= maxPendingChallenges {
+		errText := "too many pending login challenges"
+		return http.StatusServiceUnavailable, errText, nil, errors.New(errText)
+	}
+
+	kp, err := h.getSharedKeyPair(sharedKeyPairTTL)
 	if err != nil {
 		errText := "failed to generate new RSA key pair"
 		return http.StatusInternalServerError, errText, nil, fmt.Errorf("%s: %w", errText, err)
 	}
-	h.keyPairDataPool.Set(kp.getKeyPairId(), kp)
 
 	_, pemPubKey, err := kp.rsaKeyPair.GetPEM(true)
 	if err != nil {