BlueGit

timfa bluegit

Files

bluegit / internal / auth / auth.go

auth.go

feat: eerste basis van BlueGit
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
151aa352 History
auth.go 6.1 KiB Download Raw
1// Package auth praat met auth.timfalken.com.
2// De site gebruikt de authorization-code-flow: het domein is de client_id,
3// de code wordt server-side gewisseld, en /api/me levert id en gebruikersnaam.
4// E-mail komt nooit mee. Er is geen lokaal wachtwoord.
5package auth
6
7import (
8 "context"
9 "encoding/json"
10 "fmt"
11 "io"
12 "net/http"
13 "net/url"
14 "strings"
15 "time"
16)
17
18// Identity is het account dat een verbonden site mag zien.
19type Identity struct {
20 AuthID int64
21 Username string
22 AvatarURL string
23 IsAdmin bool
24 EmailVerified bool
25 AccessToken string
26 ExpiresIn int
27}
28
29// Provider is de auth-server, of een testvervanger.
30type Provider interface {
31 AuthorizeURL(state, redirectURI string) string
32 Exchange(ctx context.Context, code, redirectURI string) (Identity, error)
33 Extend(ctx context.Context, accessToken string) (expiresIn int, err error)
34 Logout(ctx context.Context, accessToken string) error
35}
36
37// TimFalken is de client voor https://auth.timfalken.com.
38type TimFalken struct {
39 BaseURL string
40 ClientID string
41 Secret string
42 UserAgent string
43 HTTP *http.Client
44}
45
46// NewTimFalken maakt een client. baseURL is zonder slash aan het eind.
47func NewTimFalken(baseURL, clientID, secret, userAgent string) *TimFalken {
48 return &TimFalken{
49 BaseURL: strings.TrimRight(baseURL, "/"),
50 ClientID: clientID,
51 Secret: secret,
52 UserAgent: userAgent,
53 HTTP: &http.Client{Timeout: 15 * time.Second},
54 }
55}
56
57// AuthorizeURL stuurt de browser naar de toestemmingspagina.
58func (t *TimFalken) AuthorizeURL(state, redirectURI string) string {
59 q := url.Values{}
60 q.Set("client_id", t.ClientID)
61 q.Set("redirect_uri", redirectURI)
62 q.Set("response_type", "code")
63 q.Set("state", state)
64 return t.BaseURL + "/oauth/authorize?" + q.Encode()
65}
66
67// Exchange wisselt de eenmalige code om voor een bearer-token.
68func (t *TimFalken) Exchange(ctx context.Context, code, redirectURI string) (Identity, error) {
69 form := url.Values{}
70 form.Set("grant_type", "authorization_code")
71 form.Set("code", code)
72 form.Set("redirect_uri", redirectURI)
73 form.Set("client_id", t.ClientID)
74 form.Set("client_secret", t.Secret)
75 req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.BaseURL+"/oauth/token", strings.NewReader(form.Encode()))
76 if err != nil {
77 return Identity{}, err
78 }
79 req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
80 req.Header.Set("Accept", "application/json")
81 req.Header.Set("User-Agent", t.UserAgent)
82 var body struct {
83 AccessToken string `json:"access_token"`
84 TokenType string `json:"token_type"`
85 ExpiresIn int `json:"expires_in"`
86 Error string `json:"error"`
87 User struct {
88 ID int64 `json:"id"`
89 Username string `json:"username"`
90 AvatarURL string `json:"avatar_url"`
91 } `json:"user"`
92 }
93 if err := t.do(req, &body); err != nil {
94 return Identity{}, err
95 }
96 if body.Error != "" || body.AccessToken == "" || body.User.ID == 0 {
97 msg := body.Error
98 if msg == "" {
99 msg = "lege tokenrespons"
100 }
101 return Identity{}, fmt.Errorf("auth: %s", msg)
102 }
103 id := Identity{
104 AuthID: body.User.ID,
105 Username: strings.ToLower(body.User.Username),
106 AvatarURL: body.User.AvatarURL,
107 AccessToken: body.AccessToken,
108 ExpiresIn: body.ExpiresIn,
109 }
110 // /api/me vult is_admin en email_verified aan. Dat is admin van de
111 // auth-server, niet van BlueGit.
112 me, err := t.me(ctx, body.AccessToken)
113 if err != nil {
114 return id, nil
115 }
116 id.IsAdmin = me.IsAdmin
117 id.EmailVerified = me.EmailVerified
118 if me.Username != "" {
119 id.Username = strings.ToLower(me.Username)
120 }
121 if me.AvatarURL != "" {
122 id.AvatarURL = me.AvatarURL
123 }
124 return id, nil
125}
126
127type meUser struct {
128 ID int64 `json:"id"`
129 Username string `json:"username"`
130 IsAdmin bool `json:"is_admin"`
131 EmailVerified bool `json:"email_verified"`
132 AvatarURL string `json:"avatar_url"`
133}
134
135func (t *TimFalken) me(ctx context.Context, token string) (meUser, error) {
136 req, err := http.NewRequestWithContext(ctx, http.MethodGet, t.BaseURL+"/api/me", nil)
137 if err != nil {
138 return meUser{}, err
139 }
140 t.bearer(req, token)
141 var body struct {
142 User meUser `json:"user"`
143 Error string `json:"error"`
144 }
145 if err := t.do(req, &body); err != nil {
146 return meUser{}, err
147 }
148 if body.Error != "" {
149 return meUser{}, fmt.Errorf("auth: %s", body.Error)
150 }
151 return body.User, nil
152}
153
154// Extend schuift de sessie een volledige dag op.
155func (t *TimFalken) Extend(ctx context.Context, accessToken string) (int, error) {
156 req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.BaseURL+"/api/session/extend", nil)
157 if err != nil {
158 return 0, err
159 }
160 t.bearer(req, accessToken)
161 var body struct {
162 ExpiresIn int `json:"expires_in"`
163 Error string `json:"error"`
164 }
165 if err := t.do(req, &body); err != nil {
166 return 0, err
167 }
168 if body.Error != "" {
169 return 0, fmt.Errorf("auth: %s", body.Error)
170 }
171 if body.ExpiresIn <= 0 {
172 body.ExpiresIn = 86400
173 }
174 return body.ExpiresIn, nil
175}
176
177// Logout trekt het bearer-token in.
178func (t *TimFalken) Logout(ctx context.Context, accessToken string) error {
179 req, err := http.NewRequestWithContext(ctx, http.MethodPost, t.BaseURL+"/api/logout", nil)
180 if err != nil {
181 return err
182 }
183 t.bearer(req, accessToken)
184 var body struct {
185 Error string `json:"error"`
186 }
187 if err := t.do(req, &body); err != nil {
188 return err
189 }
190 if body.Error != "" {
191 return fmt.Errorf("auth: %s", body.Error)
192 }
193 return nil
194}
195
196func (t *TimFalken) bearer(req *http.Request, token string) {
197 req.Header.Set("Authorization", "Bearer "+token)
198 req.Header.Set("Accept", "application/json")
199 req.Header.Set("User-Agent", t.UserAgent)
200}
201
202func (t *TimFalken) do(req *http.Request, dest any) error {
203 res, err := t.HTTP.Do(req)
204 if err != nil {
205 return fmt.Errorf("auth: %w", err)
206 }
207 defer res.Body.Close()
208 raw, err := io.ReadAll(io.LimitReader(res.Body, 1<<20))
209 if err != nil {
210 return err
211 }
212 if res.StatusCode >= 400 {
213 var env struct {
214 Error string `json:"error"`
215 }
216 _ = json.Unmarshal(raw, &env)
217 if env.Error == "" {
218 env.Error = res.Status
219 }
220 return fmt.Errorf("auth: %s", env.Error)
221 }
222 if dest == nil {
223 return nil
224 }
225 if err := json.Unmarshal(raw, dest); err != nil {
226 return fmt.Errorf("auth-antwoord: %w", err)
227 }
228 return nil
229}