Skip to content

πŸ“š The open-source, offline-first Notion, Obsidian & Confluence alternative. Advanced Markdown, multi-tenant teams, OIDC/SSO, and local S3 backups. Deploy in one command.

11.4 KB
Raw Blame
package services

import (
	"alexandrie/models"
	"alexandrie/oidc"
	"alexandrie/pkg/snowflake"
	"alexandrie/repositories"
	"alexandrie/types"
	"alexandrie/utils"
	"context"
	"crypto/rand"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"
	"sync"
	"time"
)

type StateData struct {
	Expiry time.Time
	IsLink bool
	UserID types.Snowflake
}

type OIDCService interface {
	IsEnabled() bool
	GetProviders() []oidc.PublicProvider
	GenerateAuthURL(providerName, redirectURI string, linkUserID *types.Snowflake) (string, string, error)
	ExchangeCodeForUser(providerName, code, redirectURI string) (*oidc.UserInfo, error)
	LoginOrCreate(providerName string, userInfo *oidc.UserInfo, ip, userAgent string) (*models.User, *models.Session, bool, error)
	LinkProvider(userID types.Snowflake, providerName, providerUserID string) error
	UnlinkProvider(userID types.Snowflake, providerName string) error
	GetUserProviders(userID types.Snowflake) ([]*models.UserOIDCProvider, error)
	ValidateState(state string) (*StateData, error)
}

type oidcService struct {
	oidcRepo    repositories.OIDCProviderRepository
	userRepo    repositories.UserRepository
	userService UserService
	sessionRepo repositories.SessionRepository
	logRepo     repositories.LogRepository
	snowflake   *snowflake.Snowflake
	manager     *oidc.Manager
	client      *http.Client
	states      map[string]*StateData
	statesMu    sync.RWMutex
}

func NewOIDCService(
	oidcRepo repositories.OIDCProviderRepository,
	userRepo repositories.UserRepository,
	userService UserService,
	sessionRepo repositories.SessionRepository,
	logRepo repositories.LogRepository,
	snowflake *snowflake.Snowflake,
) OIDCService {
	svc := &oidcService{
		oidcRepo:    oidcRepo,
		userRepo:    userRepo,
		userService: userService,
		sessionRepo: sessionRepo,
		logRepo:     logRepo,
		snowflake:   snowflake,
		manager:     oidc.GetManager(),
		client: &http.Client{
			Timeout: 10 * time.Second,
		},
		states: make(map[string]*StateData),
	}

	go svc.cleanupExpiredStates()

	return svc
}

func (s *oidcService) cleanupExpiredStates() {
	ticker := time.NewTicker(5 * time.Minute)
	for range ticker.C {
		s.statesMu.Lock()
		now := time.Now()
		for state, data := range s.states {
			if now.After(data.Expiry) {
				delete(s.states, state)
			}
		}
		s.statesMu.Unlock()
	}
}

func (s *oidcService) IsEnabled() bool {
	return s.manager.HasProviders()
}

func (s *oidcService) GetProviders() []oidc.PublicProvider {
	return s.manager.GetProviders()
}

func (s *oidcService) GenerateAuthURL(providerName, redirectURI string, linkUserID *types.Snowflake) (string, string, error) {
	provider, err := s.manager.GetProvider(providerName)
	if err != nil {
		return "", "", err
	}

	stateBytes := make([]byte, 32)
	if _, err := rand.Read(stateBytes); err != nil {
		return "", "", fmt.Errorf("failed to generate state: %w", err)
	}
	state := base64.URLEncoding.EncodeToString(stateBytes)

	stateData := &StateData{
		Expiry: time.Now().Add(10 * time.Minute),
		IsLink: linkUserID != nil,
	}
	if linkUserID != nil {
		stateData.UserID = *linkUserID
	}

	s.statesMu.Lock()
	s.states[state] = stateData
	s.statesMu.Unlock()

	authURL, err := url.Parse(provider.AuthorizationEndpoint)
	if err != nil {
		return "", "", fmt.Errorf("invalid authorization endpoint: %w", err)
	}

	params := url.Values{}
	params.Set("client_id", provider.ClientID)
	params.Set("response_type", "code")
	params.Set("scope", strings.Join(provider.Scopes, " "))
	params.Set("redirect_uri", redirectURI)
	params.Set("state", state)
	authURL.RawQuery = params.Encode()

	return authURL.String(), state, nil
}

func (s *oidcService) ValidateState(state string) (*StateData, error) {
	s.statesMu.Lock()
	defer s.statesMu.Unlock()

	data, exists := s.states[state]
	if !exists {
		return nil, errors.New("invalid state")
	}

	delete(s.states, state)

	if time.Now().After(data.Expiry) {
		return nil, errors.New("state expired")
	}

	return data, nil
}

func (s *oidcService) ExchangeCodeForUser(providerName, code, redirectURI string) (*oidc.UserInfo, error) {
	provider, err := s.manager.GetProvider(providerName)
	if err != nil {
		return nil, err
	}

	tokenResp, err := s.exchangeCode(provider, code, redirectURI)
	if err != nil {
		return nil, fmt.Errorf("failed to exchange code: %w", err)
	}

	userInfo, err := s.getUserInfo(provider, tokenResp.AccessToken)
	if err != nil {
		return nil, fmt.Errorf("failed to get user info: %w", err)
	}

	return userInfo, nil
}

func (s *oidcService) exchangeCode(provider *oidc.Provider, code, redirectURI string) (*oidc.TokenResponse, error) {
	data := url.Values{}
	data.Set("grant_type", "authorization_code")
	data.Set("code", code)
	data.Set("redirect_uri", redirectURI)
	data.Set("client_id", provider.ClientID)
	data.Set("client_secret", provider.ClientSecret)

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, provider.TokenEndpoint, strings.NewReader(data.Encode()))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Set("Accept", "application/json")

	resp, err := s.client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("token endpoint returned status %d: %s", resp.StatusCode, string(body))
	}

	var tokenResp oidc.TokenResponse
	if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
		return nil, fmt.Errorf("failed to decode token response: %w", err)
	}

	return &tokenResp, nil
}

func (s *oidcService) getUserInfo(provider *oidc.Provider, accessToken string) (*oidc.UserInfo, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, provider.UserinfoEndpoint, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Authorization", "Bearer "+accessToken)
	req.Header.Set("Accept", "application/json")

	resp, err := s.client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("userinfo endpoint returned status %d: %s", resp.StatusCode, string(body))
	}

	var userInfo oidc.UserInfo
	if err := json.NewDecoder(resp.Body).Decode(&userInfo); err != nil {
		return nil, fmt.Errorf("failed to decode user info: %w", err)
	}

	return &userInfo, nil
}

func (s *oidcService) LoginOrCreate(providerName string, userInfo *oidc.UserInfo, ip, userAgent string) (*models.User, *models.Session, bool, error) {

	providerName = strings.ToLower(providerName)

	link, err := s.oidcRepo.GetByProviderAndSubject(providerName, userInfo.Sub)
	if err != nil {
		return nil, nil, false, fmt.Errorf("failed to check OIDC link: %w", err)
	}
	if link != nil {
		// User already linked, perform login
		user, err := s.userRepo.GetByID(link.UserId, false)
		if err != nil || user == nil {
			return nil, nil, false, errors.New("linked user not found")
		}

		session, err := s.createSession(user, ip, userAgent)
		if err != nil {
			return nil, nil, false, err
		}

		return user, session, false, nil
	}

	// No link exists - create new user

	user, err := s.createUserFromOIDC(userInfo)
	if err != nil {
		return nil, nil, false, fmt.Errorf("failed to create user: %w", err)
	}

	if err := s.LinkProvider(user.Id, providerName, userInfo.Sub); err != nil {
		return nil, nil, false, fmt.Errorf("failed to link provider: %w", err)
	}

	session, err := s.createSession(user, ip, userAgent)
	if err != nil {
		return nil, nil, false, err
	}

	return user, session, true, nil
}

func (s *oidcService) createSession(user *models.User, ip, userAgent string) (*models.Session, error) {

	session := &models.Session{
		Id:                   s.snowflake.Generate(),
		UserId:               user.Id,
		RefreshToken:         signRefreshToken(),
		ExpireToken:          time.Now().Add(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_oidc"),
		LoginTimestamp:       time.Now().UnixMilli(),
		LogoutTimestamp:      0,
	}

	if _, err := s.sessionRepo.Create(session); err != nil {
		return nil, fmt.Errorf("failed to create session: %w", err)
	}

	return session, nil
}

// maxAvatarURLLength keeps the value well inside the users.avatar TEXT column.
const maxAvatarURLLength = 2048

// avatarFromPicture returns the OIDC picture claim when it is an http(s) URL of a sane length.
// Providers such as Authentik send a base64 data URI by default; the frontend only renders
// http(s) avatars or CDN uploads, so those values are skipped instead of stored.
func avatarFromPicture(picture *string) *string {
	if picture == nil || len(*picture) > maxAvatarURLLength {
		return nil
	}
	if !strings.HasPrefix(*picture, "https://") && !strings.HasPrefix(*picture, "http://") {
		return nil
	}
	return picture
}

func (s *oidcService) createUserFromOIDC(userInfo *oidc.UserInfo) (*models.User, error) {

	userID := s.snowflake.Generate()
	username := s.userService.GenerateUniqueUsername(userInfo.PreferredUsername, userID)
	now := time.Now().UnixMilli()
	user := &models.User{
		Id:               userID,
		Username:         username,
		Email:            userInfo.Email,
		Role:             1,
		CreatedTimestamp: now,
		UpdatedTimestamp: now,
	}
	// Set optional fields
	if userInfo.GivenName != nil && *userInfo.GivenName != "" {
		user.Firstname = userInfo.GivenName
	}
	if userInfo.FamilyName != nil && *userInfo.FamilyName != "" {
		user.Lastname = userInfo.FamilyName
	}
	user.Avatar = avatarFromPicture(userInfo.Picture)
	createdUser, err := s.userRepo.Create(user)

	if err != nil {
		return nil, err
	}

	return createdUser, nil
}

func (s *oidcService) LinkProvider(userID types.Snowflake, providerName, providerUserID string) error {
	providerName = strings.ToLower(providerName)

	existing, err := s.oidcRepo.GetByProviderAndSubject(providerName, providerUserID)
	if err != nil {
		return fmt.Errorf("failed to check existing link: %w", err)
	}
	if existing != nil {
		if existing.UserId == userID {
			return nil // Already linked to this user
		}
		return errors.New("this OIDC account is already linked to another user")
	}

	now := time.Now().UnixMilli()
	link := &models.UserOIDCProvider{
		Id:               s.snowflake.Generate(),
		UserId:           userID,
		ProviderName:     providerName,
		ProviderUserId:   providerUserID,
		CreatedTimestamp: now,
		UpdatedTimestamp: now,
	}

	_, err = s.oidcRepo.Create(link)
	return err
}

func (s *oidcService) UnlinkProvider(userID types.Snowflake, providerName string) error {
	providerName = strings.ToLower(providerName)

	links, err := s.oidcRepo.GetByUserID(userID)
	if err != nil {
		return fmt.Errorf("failed to get user OIDC links: %w", err)
	}
	userPassword, err := s.userRepo.HasPassword(userID)
	if err != nil {
		return errors.New("failed to get user password status")
	}
	if !userPassword && len(links) <= 1 {
		return errors.New("cannot unlink the only login method")
	}

	for _, link := range links {
		if strings.ToLower(link.ProviderName) == providerName {
			return s.oidcRepo.Delete(link.Id)
		}
	}

	return errors.New("provider link not found")
}

func (s *oidcService) GetUserProviders(userID types.Snowflake) ([]*models.UserOIDCProvider, error) {
	return s.oidcRepo.GetByUserID(userID)
}