BlueGit

timfa bluegit

Files

bluegit / internal / server / auth_handlers.go

auth_handlers.go

feat: nieuw-formulier, groepsoverzicht, logo's en talen
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 4 weeks ago
Failed d1203d3b History
auth_handlers.go 8.6 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.Heat = s.heatmap(r.Context(), v.User.ID, ids, s.langOf(r))
118 s.render(w, "dashboard", v)
119 return
120 }
121 ids, err := s.Store.ListRepoIDs(r.Context(), 0)
122 if err == nil {
123 v.Repos, _ = s.Store.ReposByIDs(r.Context(), ids)
124 }
125 v.Title = ""
126 s.render(w, "home", v)
127}
128
129func (s *Server) newPage(w http.ResponseWriter, r *http.Request) {
130 if _, ok := s.loginRequired(w, r); !ok {
131 return
132 }
133 v := s.view(w, r, "title.new")
134 v.Groups, _ = s.Store.ListGroups(r.Context(), v.User.ID)
135 s.render(w, "new", v)
136}
137
138func (s *Server) account(w http.ResponseWriter, r *http.Request) {
139 u, ok := s.loginRequired(w, r)
140 if !ok {
141 return
142 }
143 v := s.view(w, r, "title.account")
144 v.Tokens, _ = s.Store.ListTokens(r.Context(), u.ID)
145 v.Keys, _ = s.Store.ListSSHKeys(r.Context(), u.ID)
146 v.NewToken = cookieVal(r, "bluegit_token_once")
147 if v.NewToken != "" {
148 http.SetCookie(w, &http.Cookie{Name: "bluegit_token_once", Value: "", Path: "/", MaxAge: -1})
149 }
150 s.render(w, "account", v)
151}
152
153func (s *Server) createToken(w http.ResponseWriter, r *http.Request) {
154 u, ok := s.loginRequired(w, r)
155 if !ok || !s.csrfOK(w, r) {
156 return
157 }
158 plain, err := s.Store.CreateToken(r.Context(), u.ID, r.FormValue("name"))
159 if err != nil {
160 s.redirect(w, r, "/settings", "", s.trErr(r, err))
161 return
162 }
163 secure := strings.HasPrefix(s.Cfg.BaseURL, "https://")
164 http.SetCookie(w, &http.Cookie{Name: "bluegit_token_once", Value: plain, Path: "/settings", MaxAge: 120, HttpOnly: true, Secure: secure, SameSite: http.SameSiteLaxMode})
165 s.redirect(w, r, "/settings", s.tr(r, "flash.tokenCreated"), "")
166}
167
168func (s *Server) deleteToken(w http.ResponseWriter, r *http.Request) {
169 u, ok := s.loginRequired(w, r)
170 if !ok || !s.csrfOK(w, r) {
171 return
172 }
173 var id int64
174 _, _ = parseID(r.FormValue("id"), &id)
175 if err := s.Store.DeleteToken(r.Context(), u.ID, id); err != nil {
176 s.redirect(w, r, "/settings", "", s.tr(r, "err.tokenMissing"))
177 return
178 }
179 s.redirect(w, r, "/settings", s.tr(r, "flash.tokenRevoked"), "")
180}
181
182func (s *Server) addSSH(w http.ResponseWriter, r *http.Request) {
183 u, ok := s.loginRequired(w, r)
184 if !ok || !s.csrfOK(w, r) {
185 return
186 }
187 line := strings.TrimSpace(r.FormValue("key"))
188 pub, _, _, _, err := ssh.ParseAuthorizedKey([]byte(line))
189 if err != nil {
190 s.redirect(w, r, "/settings", "", s.tr(r, "err.sshBad"))
191 return
192 }
193 stored := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub)))
194 fp := ssh.FingerprintSHA256(pub)
195 if err := s.Store.AddSSHKey(r.Context(), u.ID, r.FormValue("name"), stored, fp); err != nil {
196 s.redirect(w, r, "/settings", "", s.trErr(r, err))
197 return
198 }
199 s.redirect(w, r, "/settings", s.tr(r, "flash.sshAdded"), "")
200}
201
202func (s *Server) deleteSSH(w http.ResponseWriter, r *http.Request) {
203 u, ok := s.loginRequired(w, r)
204 if !ok || !s.csrfOK(w, r) {
205 return
206 }
207 var id int64
208 _, _ = parseID(r.FormValue("id"), &id)
209 if err := s.Store.DeleteSSHKey(r.Context(), u.ID, id); err != nil {
210 s.redirect(w, r, "/settings", "", s.tr(r, "err.sshMissing"))
211 return
212 }
213 s.redirect(w, r, "/settings", s.tr(r, "flash.sshRemoved"), "")
214}
215
216func (s *Server) export(w http.ResponseWriter, r *http.Request) {
217 u, ok := s.loginRequired(w, r)
218 if !ok {
219 return
220 }
221 type secretRow struct {
222 Scope string `json:"scope"`
223 Name string `json:"name"`
224 Value string `json:"value"`
225 }
226 var secrets []secretRow
227 ids, _ := s.Store.ListRepoIDs(r.Context(), u.ID)
228 for _, id := range ids {
229 role, err := s.Store.EffectiveRole(r.Context(), u.ID, id)
230 if err != nil || !role.CanManageSecrets() {
231 continue
232 }
233 repo, err := s.Store.RepoByID(r.Context(), id)
234 if err != nil {
235 continue
236 }
237 vals, err := s.Store.SecretValues(r.Context(), "repo", id, true)
238 if err != nil {
239 continue
240 }
241 for name, value := range vals {
242 secrets = append(secrets, secretRow{Scope: "repo:" + repo.FullPath(), Name: name, Value: value})
243 }
244 }
245 groups, _ := s.Store.ListGroups(r.Context(), u.ID)
246 for _, g := range groups {
247 role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
248 if err != nil || !role.AtLeast(access.RoleMaintainer) {
249 continue
250 }
251 vals, err := s.Store.SecretValues(r.Context(), "group", g.ID, true)
252 if err != nil {
253 continue
254 }
255 for name, value := range vals {
256 secrets = append(secrets, secretRow{Scope: "group:" + g.Path, Name: name, Value: value})
257 }
258 }
259 tokens, _ := s.Store.ListTokens(r.Context(), u.ID)
260 keys, _ := s.Store.ListSSHKeys(r.Context(), u.ID)
261 payload := map[string]any{
262 "exported_at": time.Now().UTC().Format(time.RFC3339),
263 "account": map[string]any{
264 "id": u.AuthID,
265 "username": u.Username,
266 "avatar_url": u.AvatarURL,
267 "instance_admin": u.InstanceAdmin,
268 },
269 "tokens": tokens,
270 "ssh_keys": keys,
271 "secrets": secrets,
272 }
273 w.Header().Set("Content-Type", "application/json; charset=utf-8")
274 w.Header().Set("Content-Disposition", `attachment; filename="bluegit-export.json"`)
275 enc := json.NewEncoder(w)
276 enc.SetIndent("", " ")
277 _ = enc.Encode(payload)
278}
279
280func parseID(s string, dest *int64) (int64, error) {
281 var n int64
282 for _, c := range s {
283 if c < '0' || c > '9' {
284 return 0, errBadID
285 }
286 n = n*10 + int64(c-'0')
287 }
288 if dest != nil {
289 *dest = n
290 }
291 return n, nil
292}
293
294var errBadID = http.ErrMissingFile