π 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 oidc
import (
"context"
"encoding/json"
"fmt"
"net/http"
"os"
"slices"
"strings"
"sync"
"time"
"alexandrie/pkg/logger"
)
type Provider struct {
Name string `json:"name"`
ConfigURL string `json:"config_url"`
ClientID string `json:"client_id"`
ClientSecret string `json:"client_secret"`
// Discovered from .well-known/openid-configuration
AuthorizationEndpoint string `json:"authorization_endpoint,omitempty"`
TokenEndpoint string `json:"token_endpoint,omitempty"`
UserinfoEndpoint string `json:"userinfo_endpoint,omitempty"`
JwksURI string `json:"jwks_uri,omitempty"`
Issuer string `json:"issuer,omitempty"`
Scopes []string `json:"scopes,omitempty"` // Minimal: openid - optional: profile, email
}
type PublicProvider struct {
Name string `json:"name"`
AuthorizationEndpoint string `json:"authorization_endpoint"`
}
type OIDCDiscovery struct {
Issuer string `json:"issuer"`
AuthorizationEndpoint string `json:"authorization_endpoint"`
TokenEndpoint string `json:"token_endpoint"`
UserinfoEndpoint string `json:"userinfo_endpoint"`
JwksURI string `json:"jwks_uri"`
ScopesSupported []string `json:"scopes_supported"`
}
type TokenResponse struct {
AccessToken string `json:"access_token"`
TokenType string `json:"token_type"`
ExpiresIn int `json:"expires_in"`
RefreshToken string `json:"refresh_token,omitempty"`
IDToken string `json:"id_token,omitempty"`
Scope string `json:"scope,omitempty"`
}
type UserInfo struct {
Sub string `json:"sub"`
Email *string `json:"email"`
EmailVerified *bool `json:"email_verified"`
PreferredUsername *string `json:"preferred_username"`
Name *string `json:"name"`
GivenName *string `json:"given_name"`
FamilyName *string `json:"family_name"`
Picture *string `json:"picture"`
}
type Manager struct {
providers map[string]*Provider
mu sync.RWMutex
client *http.Client
}
var (
globalManager *Manager
once sync.Once
)
func GetManager() *Manager {
once.Do(func() {
globalManager = &Manager{
providers: make(map[string]*Provider),
client: &http.Client{
Timeout: 10 * time.Second,
},
}
globalManager.loadFromEnv()
})
return globalManager
}
func (m *Manager) loadFromEnv() {
// Try indexed providers (OIDC_1_*, OIDC_2_*, etc.)
for i := 1; i <= 10; i++ {
prefix := fmt.Sprintf("OIDC_%d_", i)
configURL := os.Getenv(prefix + "CONFIG_URL")
if configURL == "" {
continue
}
provider := &Provider{
Name: os.Getenv(prefix + "PROVIDER_NAME"),
ConfigURL: configURL,
ClientID: os.Getenv(prefix + "CLIENT_ID"),
ClientSecret: os.Getenv(prefix + "CLIENT_SECRET"),
}
if provider.Name == "" {
provider.Name = fmt.Sprintf("provider_%d", i)
}
if err := m.AddProvider(provider); err != nil {
logger.Error("OIDC", fmt.Sprintf("Failed to add OIDC provider '%s': %v", provider.Name, err))
}
}
count := len(m.providers)
if count > 0 {
logger.Success("OIDC", fmt.Sprintf("Loaded %d provider(s)", count))
} else {
logger.Info("OIDC", "No providers configured")
}
}
func (m *Manager) AddProvider(provider *Provider) error {
if provider.ConfigURL == "" {
return fmt.Errorf("provider config URL is required")
}
if provider.ClientID == "" {
return fmt.Errorf("provider client ID is required")
}
if provider.ClientSecret == "" {
return fmt.Errorf("provider client secret is required")
}
providerName := strings.ToLower(provider.Name) // To normalize provider names
discovery, err := m.discoverEndpoints(provider.ConfigURL)
if err != nil {
return fmt.Errorf("failed to discover OIDC endpoints: %w", err)
}
provider.AuthorizationEndpoint = discovery.AuthorizationEndpoint
provider.TokenEndpoint = discovery.TokenEndpoint
provider.UserinfoEndpoint = discovery.UserinfoEndpoint
provider.JwksURI = discovery.JwksURI
provider.Issuer = discovery.Issuer
// Scopes: ensure "openid" is included and add common optional scopes
provider.Scopes = []string{"openid"}
if slices.Contains(discovery.ScopesSupported, "profile") {
provider.Scopes = append(provider.Scopes, "profile")
}
if slices.Contains(discovery.ScopesSupported, "email") {
provider.Scopes = append(provider.Scopes, "email")
}
m.mu.Lock()
m.providers[providerName] = provider
m.mu.Unlock()
logger.Info("OIDC", fmt.Sprintf("Added provider '%s' (issuer: %s)", providerName, provider.Issuer))
return nil
}
func (m *Manager) discoverEndpoints(configURL string) (*OIDCDiscovery, error) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, configURL, nil)
if err != nil {
return nil, err
}
resp, err := m.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("discovery endpoint returned status %d", resp.StatusCode)
}
var discovery OIDCDiscovery
if err := json.NewDecoder(resp.Body).Decode(&discovery); err != nil {
return nil, fmt.Errorf("failed to decode discovery document: %w", err)
}
return &discovery, nil
}
func (m *Manager) GetProvider(name string) (*Provider, error) {
m.mu.RLock()
defer m.mu.RUnlock()
provider, exists := m.providers[strings.ToLower(name)]
if !exists {
return nil, fmt.Errorf("OIDC provider '%s' not found", name)
}
return provider, nil
}
func (m *Manager) GetProviders() []PublicProvider {
m.mu.RLock()
defer m.mu.RUnlock()
providers := make([]PublicProvider, 0, len(m.providers))
for _, p := range m.providers {
providers = append(providers, PublicProvider{
Name: p.Name,
AuthorizationEndpoint: p.AuthorizationEndpoint,
})
}
return providers
}
func (m *Manager) HasProviders() bool {
m.mu.RLock()
defer m.mu.RUnlock()
return len(m.providers) > 0
}
func IsEnabled() bool {
return GetManager().HasProviders()
}