BlueGit

timfa bluegit

Files

bluegit / internal / server / auth_handlers.go

auth_handlers.go

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