π The open-source, offline-first Notion, Obsidian & Confluence alternative. Advanced Markdown, multi-tenant teams, OIDC/SSO, and local S3 backups. Deploy in one command.
Vue dockergolangkanbanknowledge-baseknowledge-managementmarkdownnote-takingnotesnotes-appnotionnuxtnuxtjsoffline-firstoidcpwaselfhostedssovuevuejswiki
package services
import (
"alexandrie/models"
"alexandrie/pkg/snowflake"
"alexandrie/repositories"
"alexandrie/types"
"alexandrie/utils"
"bytes"
"crypto/rand"
"errors"
"fmt"
"html/template"
"math/big"
"os"
"strconv"
"time"
"github.com/golang-jwt/jwt/v5"
"github.com/pquerna/otp/totp"
"github.com/wneessen/go-mail"
"golang.org/x/crypto/bcrypt"
)
type AuthService interface {
Login(username, password, ip, userAgent string) (*models.User, *models.Session, string, error)
RefreshSession(refreshToken string) (*models.User, *models.Session, error)
SignAccessToken(user *models.User, accessTokenExpiry int) (string, error)
Logout(refreshToken string) error
LogoutAllDevices(userId types.Snowflake) error
RequestPasswordReset(username string, mailClient *mail.Client) error
ResetPassword(token, newPassword string) error
VerifyPreAuth(preAuthToken string) (types.Snowflake, error)
VerifyTOTPAndLogin(preAuthToken, code, ip, userAgent string) (*models.User, *models.Session, error)
GenerateTOTPSecret(user *models.User) (string, string, error)
EnableTOTP(userId types.Snowflake, secret, code string) ([]string, error)
DisableTOTP(userId types.Snowflake, code string) error
}
type authService struct {
userRepo repositories.UserRepository
sessionRepo repositories.SessionRepository
backupCodeRepo repositories.BackupCodesRepository
logRepo repositories.LogRepository
snowflake *snowflake.Snowflake
}
func NewAuthService(userRepo repositories.UserRepository, sessionRepo repositories.SessionRepository, backupCodeRepo repositories.BackupCodesRepository, logRepo repositories.LogRepository, snowflake *snowflake.Snowflake) AuthService {
return &authService{
userRepo: userRepo,
sessionRepo: sessionRepo,
backupCodeRepo: backupCodeRepo,
logRepo: logRepo,
snowflake: snowflake,
}
}
// Login user
// Find the user by username
// Compare the password with the hashed password
// Create a new session with a refresh token
// Return the user and session
func (s *authService) Login(username, password, ip, userAgent string) (*models.User, *models.Session, string, error) {
user, err := s.userRepo.GetByUsername(username)
if user == nil || err != nil {
return nil, nil, "", errors.New("invalid credentials")
}
if user.Password == nil {
return nil, nil, "", errors.New("please login with OIDC provider")
}
if err := bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(password)); err != nil {
return nil, nil, "", errors.New("invalid credentials")
}
if user.TotpEnabled || (user.TOTPForced && !user.TotpEnabled) {
user.Password = nil
preAuthToken, err := signPreAuthToken(user.Id)
if err != nil {
return nil, nil, "", errors.New("failed to generate pre-authentication token")
}
return user, nil, preAuthToken, nil
}
session := &models.Session{
Id: s.snowflake.Generate(),
UserId: user.Id,
RefreshToken: signRefreshToken(),
ExpireToken: time.Now().Add(time.Duration(30 * 24 * time.Hour)).UnixMilli(),
LastRefreshTimestamp: time.Now().UnixMilli(),
Active: 1,
IpAddr: &ip,
UserAgent: &userAgent,
Location: utils.PtrString(s.logRepo.GetLocationFromIP(ip)),
Type: utils.PtrString("login"),
LoginTimestamp: time.Now().UnixMilli(),
LogoutTimestamp: 0,
}
if _, err := s.sessionRepo.Create(session); err != nil {
return nil, nil, "", errors.New("failed to create session")
}
user.Password = nil
return user, session, "", nil
}
func (s *authService) RefreshSession(refreshToken string) (*models.User, *models.Session, error) {
session, err := s.sessionRepo.GetByRefreshToken(refreshToken)
if err != nil {
return nil, nil, errors.New("invalid refresh token")
}
if session.ExpireToken < time.Now().UnixMilli() {
return nil, nil, errors.New("refresh token expired")
}
user, err := s.userRepo.GetByID(session.UserId, false)
if user == nil || err != nil {
return nil, nil, errors.New("failed to get user")
}
session.RefreshToken = signRefreshToken()
session.ExpireToken = time.Now().Add(time.Duration(30 * 24 * time.Hour)).UnixMilli()
session.LastRefreshTimestamp = time.Now().UnixMilli()
if _, err = s.sessionRepo.Update(session); err != nil {
return nil, nil, errors.New("failed to update session")
}
user.Password = nil
return user, session, nil
}
func (s *authService) SignAccessToken(user *models.User, accessTokenExpiry int) (string, error) {
claims := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
"sub": strconv.FormatUint(uint64(user.Id), 10),
"iss": "alexandrie",
"exp": time.Now().Add(time.Duration(time.Second * time.Duration(accessTokenExpiry))).Unix(),
"iat": time.Now().Unix(),
"role": strconv.Itoa(user.Role),
})
return claims.SignedString([]byte(os.Getenv("JWT_SECRET")))
}
func (s *authService) Logout(refreshToken string) error {
session, err := s.sessionRepo.GetByRefreshToken(refreshToken)
if err != nil {
return errors.New("invalid refresh token")
}
if session.ExpireToken < time.Now().UnixMilli() {
return errors.New("refresh token expired")
}
return s.sessionRepo.Delete(session.Id, session.UserId)
}
func (s *authService) LogoutAllDevices(userId types.Snowflake) error {
return s.sessionRepo.DeleteAllByUser(userId)
}
func (s *authService) RequestPasswordReset(username string, mailClient *mail.Client) error {
if mailClient == nil {
return errors.New("mail client not configured")
}
user, err := s.userRepo.GetByUsername(username)
if user == nil || err != nil {
return nil // Don't reveal if user exists
}
if user.Email == nil {
return nil
}
resetToken := signResetToken(user.Id)
if err := s.userRepo.UpdatePasswordResetToken(user.Id, resetToken); err != nil {
return nil // Don't reveal errors
}
err = sendPasswordResetEmail(mailClient, user, resetToken)
if err != nil {
return errors.New("failed to send password reset email")
}
return nil
}
type PasswordResetEmailData struct {
ResetURL string
FrontendURL string
}
func sendPasswordResetEmail(mailClient *mail.Client, user *models.User, resetToken string) error {
mailFrom := os.Getenv("SMTP_MAIL_FROM")
if mailFrom == "" {
mailFrom = os.Getenv("SMTP_MAIL")
}
resetURL := os.Getenv("FRONTEND_URL") +
"/login/reset?token=" +
resetToken
tmpl, err := template.ParseFiles("emails/password-reset.html")
if err != nil {
return err
}
var htmlBody bytes.Buffer
data := PasswordResetEmailData{
ResetURL: resetURL,
FrontendURL: os.Getenv("FRONTEND_URL"),
}
if err := tmpl.Execute(&htmlBody, data); err != nil {
return err
}
message := mail.NewMsg()
message.FromFormat("Alexandrie Team", mailFrom)
message.To(*user.Email)
message.Subject("Alexandrie: Reset your password")
message.SetBodyString(
mail.TypeTextPlain,
"Your password reset link is: "+resetURL+"\n\n"+"If you did not expect this email, please ignore it.",
)
message.AddAlternativeString(
mail.TypeTextHTML,
htmlBody.String(),
)
if err := mailClient.DialAndSend(message); err != nil {
return errors.New("failed to send password reset email")
}
return nil
}
func (s *authService) ResetPassword(token, newPassword string) error {
claims := jwt.RegisteredClaims{}
parsedToken, err := jwt.ParseWithClaims(token, &claims, func(token *jwt.Token) (any, error) {
if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, errors.New("invalid signing method")
}
return []byte(os.Getenv("JWT_SECRET")), nil
})
if err != nil || !parsedToken.Valid {
return errors.New("invalid reset token")
}
userId, err := strconv.ParseUint(claims.Subject, 10, 64)
if err != nil {
return errors.New("invalid user ID in reset token")
}
user, err := s.userRepo.GetByID(types.Snowflake(userId), false)
if user == nil || err != nil {
return errors.New("failed to get user")
}
hash, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
if err != nil {
return errors.New("failed to hash password")
}
return s.userRepo.UpdatePassword(user.Id, string(hash))
}
func (s *authService) VerifyPreAuth(preAuthToken string) (types.Snowflake, error) {
token, err := jwt.Parse(preAuthToken, func(token *jwt.Token) (any, error) {
return []byte(os.Getenv("JWT_SECRET")), nil
})
if err != nil || !token.Valid {
return types.Snowflake(0), errors.New("invalid or expired pre-authentication token")
}
claims, ok := token.Claims.(jwt.MapClaims)
if !ok || claims["pre_auth"] != true {
return types.Snowflake(0), errors.New("invalid token type")
}
userIdStr, _ := claims["sub"].(string)
userIdUint, err := strconv.ParseUint(userIdStr, 10, 64)
if err != nil {
return types.Snowflake(0), errors.New("invalid user ID")
}
userId := types.Snowflake(userIdUint)
return userId, nil
}
func (s *authService) VerifyTOTPAndLogin(preAuthToken, code, ip, userAgent string) (*models.User, *models.Session, error) {
userId, err := s.VerifyPreAuth(preAuthToken)
if err != nil {
return nil, nil, err
}
user, err := s.userRepo.GetByID(userId, true)
if user == nil || err != nil {
return nil, nil, errors.New("user not found")
}
if !s.validateCode(user, code) {
return nil, nil, errors.New("invalid 2FA code")
}
session := &models.Session{
Id: s.snowflake.Generate(),
UserId: user.Id,
RefreshToken: signRefreshToken(),
ExpireToken: time.Now().Add(time.Duration(30 * 24 * time.Hour)).UnixMilli(),
LastRefreshTimestamp: time.Now().UnixMilli(),
Active: 1,
IpAddr: &ip,
UserAgent: &userAgent,
Location: utils.PtrString(s.logRepo.GetLocationFromIP(ip)),
Type: utils.PtrString("login"),
LoginTimestamp: time.Now().UnixMilli(),
LogoutTimestamp: 0,
}
if _, err := s.sessionRepo.Create(session); err != nil {
return nil, nil, errors.New("failed to create session")
}
user.Password = nil
return user, session, nil
}
func (s *authService) GenerateTOTPSecret(user *models.User) (string, string, error) {
key, err := totp.Generate(totp.GenerateOpts{
Issuer: "Alexandrie",
AccountName: user.Username,
})
if err != nil {
return "", "", errors.New("failed to generate TOTP key")
}
return key.Secret(), key.URL(), nil
}
func generateBackupCodes() ([]string, error) {
codes := make([]string, 8)
for i := range 8 {
nBig, err := rand.Int(rand.Reader, big.NewInt(90000000))
if err != nil {
return nil, err
}
codes[i] = fmt.Sprintf("%08d", nBig.Uint64()+10000000)
}
return codes, nil
}
func (s *authService) EnableTOTP(userId types.Snowflake, secret, code string) ([]string, error) {
valid := totp.Validate(code, secret)
if !valid {
return nil, errors.New("invalid verification code")
}
plainCodes, err := generateBackupCodes()
if err != nil {
return nil, errors.New("failed to generate backup codes")
}
backupCodes := make([]models.UserTOTPRecoveryCode, 0, len(plainCodes))
for _, plainCode := range plainCodes {
hash, _ := bcrypt.GenerateFromPassword([]byte(plainCode), bcrypt.DefaultCost)
backupCodes = append(backupCodes, models.UserTOTPRecoveryCode{
Id: s.snowflake.Generate(),
UserId: userId,
Code: string(hash),
Used: false,
CreatedTimestamp: time.Now().UnixMilli(),
})
}
err = s.backupCodeRepo.Create(backupCodes)
if err != nil {
return nil, errors.New("failed to create backup codes")
}
return plainCodes, s.userRepo.UpdateTOTP(userId, secret, true)
}
func (s *authService) DisableTOTP(userId types.Snowflake, code string) error {
user, err := s.userRepo.GetByID(userId, true)
if err != nil {
return errors.New("failed to get user")
}
valid := s.validateCode(user, code)
if !valid {
return errors.New("invalid verification code")
}
err = s.userRepo.UpdateTOTP(userId, "", false)
if err != nil {
return errors.New("failed to disable TOTP")
}
return s.backupCodeRepo.DeleteByUserId(userId)
}
func (s *authService) validateCode(user *models.User, code string) bool {
valid := false
if len(code) == 6 {
valid = totp.Validate(code, *user.TotpSecret)
} else if len(code) == 8 {
backupCodes, err := s.backupCodeRepo.GetActiveCodesByUserId(user.Id)
if err == nil {
for _, bc := range backupCodes {
if bcrypt.CompareHashAndPassword([]byte(bc.Code), []byte(code)) == nil {
valid = true
s.backupCodeRepo.MarkAsUsed(bc.Id)
break
}
}
}
}
return valid
}
func signPreAuthToken(userId types.Snowflake) (string, error) {
claims := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
"sub": strconv.FormatUint(uint64(userId), 10),
"iss": "alexandrie",
"exp": time.Now().Add(3 * time.Minute).Unix(),
"iat": time.Now().Unix(),
"pre_auth": true,
})
return claims.SignedString([]byte(os.Getenv("JWT_SECRET")))
}
func signRefreshToken() string {
randBytes := make([]byte, 45)
rand.Read(randBytes)
return fmt.Sprintf("%x", randBytes)
}
func signResetToken(userId types.Snowflake) string {
claims := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
"sub": strconv.FormatUint(uint64(userId), 10),
"exp": time.Now().Add(time.Duration(time.Minute * 20)).Unix(),
})
tokenString, err := claims.SignedString([]byte(os.Getenv("JWT_SECRET")))
if err != nil {
return ""
}
return tokenString
}