BlueGit

timfa bluegit

Files

bluegit / internal / server / auth_handlers.go

auth_handlers.go

fix: compacte token- en SSH-knoppen op /settings
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
25146e27 History
auth_handlers.go 8.8 KiB Download Raw
1package server
2
3import (
4 "encoding/json"
5 "net/http"
6 "strings"
7 "time"
8
9 "gitlab.com/Timfa/bluegit/internal/access"
10 "golang.org/x/crypto/ssh"
11)
12
13func (s *Server) login(w http.ResponseWriter, r *http.Request) {
14 if s.who(r).OK {
15 http.Redirect(w, r, "/", http.StatusFound)
16 return
17 }
18 if s.Dev {
19 id, err := s.Auth.Exchange(r.Context(), "dev", s.Cfg.RedirectURI())
20 if err != nil {
21 http.Error(w, err.Error(), http.StatusBadGateway)
22 return
23 }
24 s.finishLogin(w, r, id.AuthID, id.Username, id.AvatarURL, id.IsAdmin, id.AccessToken, id.ExpiresIn)
25 return
26 }
27 state, err := randomState()
28 if err != nil {
29 http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError)
30 return
31 }
32 secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
33 http.SetCookie(w, &http.Cookie{
34 Name: "bluegit_oauth_state", Value: state, Path: "/", MaxAge: 600,
35 HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode,
36 })
37 http.Redirect(w, r, s.Auth.AuthorizeURL(state, s.Cfg.RedirectURI()), http.StatusFound)
38}
39
40func (s *Server) callback(w http.ResponseWriter, r *http.Request) {
41 if s.Dev {
42 http.NotFound(w, r)
43 return
44 }
45 if msg := r.URL.Query().Get("error"); msg != "" {
46 s.redirect(w, r, "/login", "", s.tr(r, "err.oauth", msg))
47 return
48 }
49 stateCookie, err := r.Cookie("bluegit_oauth_state")
50 if err != nil || stateCookie.Value == "" || stateCookie.Value != r.URL.Query().Get("state") {
51 http.Error(w, s.tr(r, "err.oauthState"), http.StatusBadRequest)
52 return
53 }
54 http.SetCookie(w, &http.Cookie{Name: "bluegit_oauth_state", Value: "", Path: "/", MaxAge: -1})
55 id, err := s.Auth.Exchange(r.Context(), r.URL.Query().Get("code"), s.Cfg.RedirectURI())
56 if err != nil {
57 s.Log.Error("oauth", "err", err)
58 s.redirect(w, r, "/", "", s.tr(r, "err.oauthFail"))
59 return
60 }
61 s.finishLogin(w, r, id.AuthID, id.Username, id.AvatarURL, id.IsAdmin, id.AccessToken, id.ExpiresIn)
62}
63
64func (s *Server) finishLogin(w http.ResponseWriter, r *http.Request, authID int64, username, avatar string, authAdmin bool, token string, expiresIn int) {
65 if expiresIn <= 0 {
66 expiresIn = 86400
67 }
68 user, err := s.Store.UpsertUser(r.Context(), authID, username, avatar, authAdmin)
69 if err != nil {
70 http.Error(w, err.Error(), http.StatusBadRequest)
71 return
72 }
73 exp := time.Now().Add(time.Duration(expiresIn) * time.Second)
74 sess, err := s.Store.CreateSession(r.Context(), user.ID, token, exp)
75 if err != nil {
76 http.Error(w, s.tr(r, "err.session"), http.StatusInternalServerError)
77 return
78 }
79 s.setSessionCookie(w, sess.ID, exp)
80 s.redirect(w, r, "/", s.tr(r, "flash.welcome", user.Username), "")
81}
82
83func (s *Server) logout(w http.ResponseWriter, r *http.Request) {
84 if !s.csrfOK(w, r) {
85 return
86 }
87 p := s.who(r)
88 if p.OK {
89 _ = s.Auth.Logout(r.Context(), p.Session.AccessToken)
90 _ = s.Store.DeleteSession(r.Context(), p.Session.ID)
91 }
92 http.SetCookie(w, &http.Cookie{Name: "bluegit_session", Value: "", Path: "/", MaxAge: -1})
93 http.Redirect(w, r, "/", http.StatusSeeOther)
94}
95
96func (s *Server) home(w http.ResponseWriter, r *http.Request) {
97 v := s.view(w, r, "BlueGit")
98 if v.User != nil {
99 ids, err := s.Store.ListRepoIDs(r.Context(), v.User.ID)
100 if err != nil {
101 http.Error(w, s.tr(r, "err.overview"), http.StatusInternalServerError)
102 return
103 }
104 repos, err := s.Store.ReposByIDs(r.Context(), ids)
105 if err != nil {
106 http.Error(w, s.tr(r, "err.overview"), http.StatusInternalServerError)
107 return
108 }
109 v.Repos = repos
110 groups, err := s.Store.ListGroups(r.Context(), v.User.ID)
111 if err != nil {
112 http.Error(w, s.tr(r, "err.overview"), http.StatusInternalServerError)
113 return
114 }
115 v.Groups = groups
116 v.Title = s.tr(r, "nav.dashboard")
117 v.Page = "dashboard"
118 v.Heat = s.heatmap(r.Context(), v.User.ID, ids, s.langOf(r))
119 s.render(w, "dashboard", v)
120 return
121 }
122 ids, err := s.Store.ListRepoIDs(r.Context(), 0)
123 if err == nil {
124 v.Repos, _ = s.Store.ReposByIDs(r.Context(), ids)
125 }
126 v.Title = ""
127 s.render(w, "home", v)
128}
129
130func (s *Server) newPage(w http.ResponseWriter, r *http.Request) {
131 if _, ok := s.loginRequired(w, r); !ok {
132 return
133 }
134 v := s.view(w, r, "title.new")
135 v.Page = "new"
136 v.Groups, _ = s.Store.ListGroups(r.Context(), v.User.ID)
137 s.render(w, "new", v)
138}
139
140func (s *Server) account(w http.ResponseWriter, r *http.Request) {
141 u, ok := s.loginRequired(w, r)
142 if !ok {
143 return
144 }
145 v := s.view(w, r, "title.account")
146 v.Page = "account"
147 v.Tokens, _ = s.Store.ListTokens(r.Context(), u.ID)
148 for _, tok := range v.Tokens {
149 if !tok.ExpiresAt.IsZero() {
150 v.ShowExpiry = true
151 break
152 }
153 }
154 v.Keys, _ = s.Store.ListSSHKeys(r.Context(), u.ID)
155 v.NewToken = cookieVal(r, "bluegit_token_once")
156 if v.NewToken != "" {
157 http.SetCookie(w, &http.Cookie{Name: "bluegit_token_once", Value: "", Path: "/", MaxAge: -1})
158 }
159 s.render(w, "account", v)
160}
161
162func (s *Server) createToken(w http.ResponseWriter, r *http.Request) {
163 u, ok := s.loginRequired(w, r)
164 if !ok || !s.csrfOK(w, r) {
165 return
166 }
167 plain, err := s.Store.CreateToken(r.Context(), u.ID, r.FormValue("name"))
168 if err != nil {
169 s.redirect(w, r, "/settings", "", s.trErr(r, err))
170 return
171 }
172 secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
173 http.SetCookie(w, &http.Cookie{Name: "bluegit_token_once", Value: plain, Path: "/settings", MaxAge: 120, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode})
174 s.redirect(w, r, "/settings", s.tr(r, "flash.tokenCreated"), "")
175}
176
177func (s *Server) deleteToken(w http.ResponseWriter, r *http.Request) {
178 u, ok := s.loginRequired(w, r)
179 if !ok || !s.csrfOK(w, r) {
180 return
181 }
182 var id int64
183 _, _ = parseID(r.FormValue("id"), &id)
184 if err := s.Store.DeleteToken(r.Context(), u.ID, id); err != nil {
185 s.redirect(w, r, "/settings", "", s.tr(r, "err.tokenMissing"))
186 return
187 }
188 s.redirect(w, r, "/settings", s.tr(r, "flash.tokenRevoked"), "")
189}
190
191func (s *Server) addSSH(w http.ResponseWriter, r *http.Request) {
192 u, ok := s.loginRequired(w, r)
193 if !ok || !s.csrfOK(w, r) {
194 return
195 }
196 line := strings.TrimSpace(r.FormValue("key"))
197 pub, _, _, _, err := ssh.ParseAuthorizedKey([]byte(line))
198 if err != nil {
199 s.redirect(w, r, "/settings", "", s.tr(r, "err.sshBad"))
200 return
201 }
202 stored := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub)))
203 fp := ssh.FingerprintSHA256(pub)
204 if err := s.Store.AddSSHKey(r.Context(), u.ID, r.FormValue("name"), stored, fp); err != nil {
205 s.redirect(w, r, "/settings", "", s.trErr(r, err))
206 return
207 }
208 s.redirect(w, r, "/settings", s.tr(r, "flash.sshAdded"), "")
209}
210
211func (s *Server) deleteSSH(w http.ResponseWriter, r *http.Request) {
212 u, ok := s.loginRequired(w, r)
213 if !ok || !s.csrfOK(w, r) {
214 return
215 }
216 var id int64
217 _, _ = parseID(r.FormValue("id"), &id)
218 if err := s.Store.DeleteSSHKey(r.Context(), u.ID, id); err != nil {
219 s.redirect(w, r, "/settings", "", s.tr(r, "err.sshMissing"))
220 return
221 }
222 s.redirect(w, r, "/settings", s.tr(r, "flash.sshRemoved"), "")
223}
224
225func (s *Server) export(w http.ResponseWriter, r *http.Request) {
226 u, ok := s.loginRequired(w, r)
227 if !ok {
228 return
229 }
230 type secretRow struct {
231 Scope string `json:"scope"`
232 Name string `json:"name"`
233 Value string `json:"value"`
234 }
235 var secrets []secretRow
236 ids, _ := s.Store.ListRepoIDs(r.Context(), u.ID)
237 for _, id := range ids {
238 role, err := s.Store.EffectiveRole(r.Context(), u.ID, id)
239 if err != nil || !role.CanManageSecrets() {
240 continue
241 }
242 repo, err := s.Store.RepoByID(r.Context(), id)
243 if err != nil {
244 continue
245 }
246 vals, err := s.Store.SecretValues(r.Context(), "repo", id, true)
247 if err != nil {
248 continue
249 }
250 for name, value := range vals {
251 secrets = append(secrets, secretRow{Scope: "repo:" + repo.FullPath(), Name: name, Value: value})
252 }
253 }
254 groups, _ := s.Store.ListGroups(r.Context(), u.ID)
255 for _, g := range groups {
256 role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
257 if err != nil || !role.AtLeast(access.RoleMaintainer) {
258 continue
259 }
260 vals, err := s.Store.SecretValues(r.Context(), "group", g.ID, true)
261 if err != nil {
262 continue
263 }
264 for name, value := range vals {
265 secrets = append(secrets, secretRow{Scope: "group:" + g.Path, Name: name, Value: value})
266 }
267 }
268 tokens, _ := s.Store.ListTokens(r.Context(), u.ID)
269 keys, _ := s.Store.ListSSHKeys(r.Context(), u.ID)
270 payload := map[string]any{
271 "exported_at": time.Now().UTC().Format(time.RFC3339),
272 "account": map[string]any{
273 "id": u.AuthID,
274 "username": u.Username,
275 "avatar_url": u.AvatarURL,
276 "instance_admin": u.InstanceAdmin,
277 },
278 "tokens": tokens,
279 "ssh_keys": keys,
280 "secrets": secrets,
281 }
282 w.Header().Set("Content-Type", "application/json; charset=utf-8")
283 w.Header().Set("Content-Disposition", `attachment; filename="bluegit-export.json"`)
284 enc := json.NewEncoder(w)
285 enc.SetIndent("", " ")
286 _ = enc.Encode(payload)
287}
288
289func parseID(s string, dest *int64) (int64, error) {
290 var n int64
291 for _, c := range s {
292 if c < '0' || c > '9' {
293 return 0, errBadID
294 }
295 n = n*10 + int64(c-'0')
296 }
297 if dest != nil {
298 *dest = n
299 }
300 return n, nil
301}
302
303var errBadID = http.ErrMissingFile