Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

9.3 KB
Raw Blame
package user

import (
	"bytes"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"image/png"

	"github.com/ente/museum/pkg/utils/network"

	"github.com/ente/museum/ente"
	"github.com/ente/museum/pkg/repo"
	"github.com/ente/museum/pkg/utils/auth"
	"github.com/ente/museum/pkg/utils/crypto"
	"github.com/ente/museum/pkg/utils/time"
	"github.com/ente/stacktrace"
	"github.com/gin-gonic/gin"
	"github.com/pquerna/otp/totp"
	log "github.com/sirupsen/logrus"
)

func (c *UserController) SetupTwoFactor(userID int64) (ente.TwoFactorSecret, error) {
	user, err := c.UserRepo.Get(userID)
	if err != nil {
		return ente.TwoFactorSecret{}, stacktrace.Propagate(err, "")
	}
	if _, keyErr := c.UserRepo.GetKeyAttributes(userID); keyErr != nil {
		return ente.TwoFactorSecret{}, stacktrace.Propagate(keyErr, "User keys setup is not completed")
	}
	key, err := totp.Generate(totp.GenerateOpts{Issuer: TOTPIssuerORG, AccountName: user.Email})
	if err != nil {
		return ente.TwoFactorSecret{}, stacktrace.Propagate(err, "")
	}
	encryptedSecret, err := crypto.Encrypt(key.Secret(), c.SecretEncryptionKey)
	if err != nil {
		return ente.TwoFactorSecret{}, stacktrace.Propagate(err, "")
	}
	secretHash, err := crypto.GetHash(key.Secret(), c.HashingKey)
	if err != nil {
		return ente.TwoFactorSecret{}, stacktrace.Propagate(err, "")
	}
	err = c.TwoFactorRepo.SetTempTwoFactorSecret(userID, encryptedSecret, secretHash, time.Microseconds()+TwoFactorValidityDurationInMicroSeconds)
	if err != nil {
		return ente.TwoFactorSecret{}, stacktrace.Propagate(err, "")
	}
	buf := new(bytes.Buffer)
	img, err := key.Image(200, 200)
	if err != nil {
		return ente.TwoFactorSecret{}, stacktrace.Propagate(err, "")
	}
	err = png.Encode(buf, img)
	if err != nil {
		return ente.TwoFactorSecret{}, stacktrace.Propagate(err, "")
	}
	return ente.TwoFactorSecret{SecretCode: key.Secret(), QRCode: base64.StdEncoding.EncodeToString(buf.Bytes())}, nil
}

func (c *UserController) EnableTwoFactor(userID int64, request ente.TwoFactorEnableRequest) error {
	recoverySecret, err := base64.StdEncoding.DecodeString(request.EncryptedTwoFactorSecret)
	if err != nil || len(recoverySecret) != 40 {
		return ente.NewBadRequestWithMessage("Invalid two-factor recovery data. Update your client and try again.")
	}
	recoveryNonce, err := base64.StdEncoding.DecodeString(request.TwoFactorSecretDecryptionNonce)
	if err != nil || len(recoveryNonce) != 24 {
		return ente.NewBadRequestWithMessage("Invalid two-factor recovery nonce")
	}
	encryptedSecrets, hashedSecrets, err := c.TwoFactorRepo.GetTempTwoFactorSecret(userID)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	valid := false
	validSecret := ""
	var validEncryptedSecret ente.EncryptionResult
	var validSecretHash string
	for index, encryptedSecret := range encryptedSecrets {
		secret, err := crypto.Decrypt(encryptedSecret.Cipher, c.SecretEncryptionKey, encryptedSecret.Nonce)
		if err != nil {
			return stacktrace.Propagate(err, "")
		}
		valid = totp.Validate(request.Code, secret)
		if valid {
			validSecret = secret
			validEncryptedSecret = encryptedSecret
			validSecretHash = hashedSecrets[index]
			break
		}
	}
	if !valid {
		return stacktrace.Propagate(ente.ErrIncorrectTOTP, "")
	}
	err = c.UserRepo.SetTwoFactorSecret(userID, validEncryptedSecret, validSecretHash, request.EncryptedTwoFactorSecret, request.TwoFactorSecretDecryptionNonce)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	err = c.TwoFactorRepo.UpdateTwoFactorStatus(userID, true)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	secretHash, err := crypto.GetHash(validSecret, c.HashingKey)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	err = c.TwoFactorRepo.RemoveTempTwoFactorSecret(secretHash)
	return stacktrace.Propagate(err, "")
}

func (c *UserController) VerifyTwoFactor(context *gin.Context, sessionID string, otp string) (ente.TwoFactorAuthorizationResponse, error) {
	userID, err := c.TwoFactorRepo.GetUserIDWithTwoFactorSession(sessionID)
	if err != nil {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	isTwoFactorEnabled, err := c.UserRepo.IsTwoFactorEnabled(userID)
	if err != nil {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	if !isTwoFactorEnabled {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(ente.ErrBadRequest, "")
	}

	secret, err := c.TwoFactorRepo.GetTwoFactorSecret(userID)
	if err != nil {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	reserved, err := c.TwoFactorRepo.ReserveTwoFactorAttempt(sessionID)
	if err != nil {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	if !reserved {
		msg := fmt.Sprintf("Too many wrong two-factor verification attempts for userID: %d", userID)
		go c.DiscordController.NotifyPotentialAbuse(msg)
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(ente.ErrTooManyBadRequest, "Too many wrong attempts, please request a new verification session")
	}
	valid := totp.Validate(otp, secret)
	if !valid {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(ente.ErrIncorrectTOTP, "")
	}

	hashData := fmt.Sprintf("%d:%s", userID, otp)
	hash := sha256.Sum256([]byte(hashData))
	otpHash := hex.EncodeToString(hash[:])

	wasNew, err := c.TwoFactorRepo.TryRecordUsedOTPCode(userID, otpHash)
	if err != nil {
		log.WithError(err).Error("Failed to record used OTP code")
		// Continue anyway to not break authentication
	} else if !wasNew {
		msg := fmt.Sprintf("Replay attack detected for userID: %d - OTP code reused", userID)
		log.Warn(msg)
		go c.DiscordController.NotifyPotentialAbuse(msg)
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(ente.ErrIncorrectTOTP, "OTP code has already been used")
	}
	response, err := c.GetKeyAttributeAndToken(context, userID, sessionID, repo.TOTPPendingLogin, false, false)
	if err != nil {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	return response, nil
}

func (c *UserController) DisableTwoFactor(userID int64) error {
	err := c.TwoFactorRepo.UpdateTwoFactorStatus(userID, false)
	return stacktrace.Propagate(err, "")
}

func (c *UserController) RecoverTwoFactor(sessionID string) (*ente.TwoFactorRecoveryResponse, error) {
	userID, err := c.TwoFactorRepo.GetUserIDWithTwoFactorSession(sessionID)
	if err != nil {
		return nil, stacktrace.Propagate(err, "")
	}
	response, err := c.TwoFactorRepo.GetRecoveryKeyEncryptedTwoFactorSecret(userID)
	if err != nil {
		return nil, stacktrace.Propagate(err, "")
	}
	return &response, nil
}

func (c *UserController) RemoveTOTPTwoFactor(context *gin.Context, req *ente.TwoFactorRemovalRequest) (*ente.TwoFactorAuthorizationResponse, error) {
	userID, err := c.TwoFactorRepo.GetUserIDWithTwoFactorSession(req.SessionID)
	if err != nil {
		return nil, stacktrace.Propagate(err, "")
	}
	var valid bool
	if req.Proof != "" {
		secret, err := c.TwoFactorRepo.GetTwoFactorSecret(userID)
		if err != nil {
			return nil, stacktrace.Propagate(err, "")
		}
		valid = verifyRecoveryProof(secret, "totp", req.SessionID, req.Proof)
	} else {
		secretHash, err := crypto.GetHash(req.Secret, c.HashingKey)
		if err != nil {
			return nil, stacktrace.Propagate(err, "")
		}
		valid, err = c.TwoFactorRepo.VerifyTwoFactorSecret(userID, secretHash)
		if err != nil {
			return nil, stacktrace.Propagate(err, "")
		}
	}
	if !valid {
		return nil, stacktrace.Propagate(ente.ErrPermissionDenied, "")
	}
	response, err := c.GetKeyAttributeAndToken(context, userID, req.SessionID, repo.TOTPPendingLogin, true, false)
	if err != nil {
		return nil, stacktrace.Propagate(err, "")
	}
	return &response, nil
}

func verifyRecoveryProof(secret, factor, sessionID, proof string) bool {
	mac := hmac.New(sha256.New, []byte(secret))
	mac.Write([]byte("recovery:" + factor + ":" + sessionID))
	expected := base64.StdEncoding.EncodeToString(mac.Sum(nil))
	return hmac.Equal([]byte(proof), []byte(expected))
}

func (c *UserController) GetKeyAttributeAndToken(context *gin.Context, userID int64, sessionID string,
	session repo.PendingLoginSession, disableTwoFactor, publishForPolling bool,
) (ente.TwoFactorAuthorizationResponse, error) {
	keyAttributes, err := c.UserRepo.GetKeyAttributes(userID)
	if err != nil {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	token := generateAuthToken()
	encryptedToken, err := crypto.GetEncryptedToken(token, keyAttributes.PublicKey)
	if err != nil {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	app := auth.GetApp(context)
	ip := network.GetClientIP(context)
	userAgent := context.Request.UserAgent()
	response := ente.TwoFactorAuthorizationResponse{
		ID:             userID,
		KeyAttributes:  &keyAttributes,
		EncryptedToken: encryptedToken,
	}
	if session == repo.NoPendingLogin {
		err = c.AddTokenAndNotify(context, userID, app, token, ip, userAgent)
	} else if err = c.ensureStorageWarningDeletionLoginAllowed(userID, app); err == nil {
		var tokenData []byte
		if publishForPolling {
			tokenData, err = json.Marshal(response)
		}
		if err == nil {
			err = c.UserAuthRepo.AddTokenForPendingLogin(context, userID, sessionID, session, disableTwoFactor, app, token, ip, userAgent, tokenData)
		}
		if err == nil {
			err = c.notifyLogin(context, userID, app, ip, userAgent)
		}
	}
	if err != nil {
		return ente.TwoFactorAuthorizationResponse{}, stacktrace.Propagate(err, "")
	}
	return response, nil
}