// Package auth praat met auth.timfalken.com. // De site gebruikt de authorization-code-flow: het domein is de client_id, // de code wordt server-side gewisseld, en /api/me levert id en gebruikersnaam. // E-mail komt nooit mee. Er is geen lokaal wachtwoord. package auth import ( "context" "encoding/json" "fmt" "io" "net/http" "net/url" "strings" "time" ) // Identity is het account dat een verbonden site mag zien. type Identity struct { AuthID int64 Username string AvatarURL string IsAdmin bool EmailVerified bool AccessToken string ExpiresIn int } // Provider is de auth-server, of een testvervanger. type Provider interface { AuthorizeURL(state, redirectURI string) string Exchange(ctx context.Context, code, redirectURI string) (Identity, error) Extend(ctx context.Context, accessToken string) (expiresIn int, err error) Logout(ctx context.Context, accessToken string) error } // TimFalken is de client voor https://auth.timfalken.com. type TimFalken struct { BaseURL string ClientID string Secret string UserAgent string HTTP *http.Client } // NewTimFalken maakt een client. baseURL is zonder slash aan het eind. func NewTimFalken(baseURL, clientID, secret, userAgent string) *TimFalken { return &TimFalken{ BaseURL: strings.TrimRight(baseURL, "/"), ClientID: clientID, Secret: secret, UserAgent: userAgent, HTTP: &http.Client{Timeout: 15 * time.Second}, } } // AuthorizeURL stuurt de browser naar de toestemmingspagina. func (t *TimFalken) AuthorizeURL(state, redirectURI string) string { q := url.Values{} q.Set("client_id", t.ClientID) q.Set("redirect_uri", redirectURI) q.Set("response_type", "code") q.Set("state", state) return t.BaseURL + "/oauth/authorize?" + q.Encode() } // Exchange wisselt de eenmalige code om voor een bearer-token. func (t *TimFalken) Exchange(ctx context.Context, code, redirectURI string) (Identity, error) { form := url.Values{} form.Set("grant_type", "authorization_code") form.Set("code", code) form.Set("redirect_uri", redirectURI) form.Set("client_id", t.ClientID) form.Set("client_secret", t.Secret) req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.BaseURL+"/oauth/token", strings.NewReader(form.Encode())) if err != nil { return Identity{}, err } req.Header.Set("Content-Type", "application/x-www-form-urlencoded") req.Header.Set("Accept", "application/json") req.Header.Set("User-Agent", t.UserAgent) var body struct { AccessToken string `json:"access_token"` TokenType string `json:"token_type"` ExpiresIn int `json:"expires_in"` Error string `json:"error"` User struct { ID int64 `json:"id"` Username string `json:"username"` AvatarURL string `json:"avatar_url"` } `json:"user"` } if err := t.do(req, &body); err != nil { return Identity{}, err } if body.Error != "" || body.AccessToken == "" || body.User.ID == 0 { msg := body.Error if msg == "" { msg = "lege tokenrespons" } return Identity{}, fmt.Errorf("auth: %s", msg) } id := Identity{ AuthID: body.User.ID, Username: strings.ToLower(body.User.Username), AvatarURL: body.User.AvatarURL, AccessToken: body.AccessToken, ExpiresIn: body.ExpiresIn, } // /api/me vult is_admin en email_verified aan. Dat is admin van de // auth-server, niet van BlueGit. me, err := t.me(ctx, body.AccessToken) if err != nil { return id, nil } id.IsAdmin = me.IsAdmin id.EmailVerified = me.EmailVerified if me.Username != "" { id.Username = strings.ToLower(me.Username) } if me.AvatarURL != "" { id.AvatarURL = me.AvatarURL } return id, nil } type meUser struct { ID int64 `json:"id"` Username string `json:"username"` IsAdmin bool `json:"is_admin"` EmailVerified bool `json:"email_verified"` AvatarURL string `json:"avatar_url"` } func (t *TimFalken) me(ctx context.Context, token string) (meUser, error) { req, err := http.NewRequestWithContext(ctx, http.MethodGet, t.BaseURL+"/api/me", nil) if err != nil { return meUser{}, err } t.bearer(req, token) var body struct { User meUser `json:"user"` Error string `json:"error"` } if err := t.do(req, &body); err != nil { return meUser{}, err } if body.Error != "" { return meUser{}, fmt.Errorf("auth: %s", body.Error) } return body.User, nil } // Extend schuift de sessie een volledige dag op. func (t *TimFalken) Extend(ctx context.Context, accessToken string) (int, error) { req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.BaseURL+"/api/session/extend", nil) if err != nil { return 0, err } t.bearer(req, accessToken) var body struct { ExpiresIn int `json:"expires_in"` Error string `json:"error"` } if err := t.do(req, &body); err != nil { return 0, err } if body.Error != "" { return 0, fmt.Errorf("auth: %s", body.Error) } if body.ExpiresIn <= 0 { body.ExpiresIn = 86400 } return body.ExpiresIn, nil } // Logout trekt het bearer-token in. func (t *TimFalken) Logout(ctx context.Context, accessToken string) error { req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.BaseURL+"/api/logout", nil) if err != nil { return err } t.bearer(req, accessToken) var body struct { Error string `json:"error"` } if err := t.do(req, &body); err != nil { return err } if body.Error != "" { return fmt.Errorf("auth: %s", body.Error) } return nil } func (t *TimFalken) bearer(req *http.Request, token string) { req.Header.Set("Authorization", "Bearer "+token) req.Header.Set("Accept", "application/json") req.Header.Set("User-Agent", t.UserAgent) } func (t *TimFalken) do(req *http.Request, dest any) error { res, err := t.HTTP.Do(req) if err != nil { return fmt.Errorf("auth: %w", err) } defer res.Body.Close() raw, err := io.ReadAll(io.LimitReader(res.Body, 1<<20)) if err != nil { return err } if res.StatusCode >= 400 { var env struct { Error string `json:"error"` } _ = json.Unmarshal(raw, &env) if env.Error == "" { env.Error = res.Status } return fmt.Errorf("auth: %s", env.Error) } if dest == nil { return nil } if err := json.Unmarshal(raw, dest); err != nil { return fmt.Errorf("auth-antwoord: %w", err) } return nil }