π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
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
}