BlueGit

timfa bluegit

Files

bluegit / internal / server / auth_handlers.go

auth_handlers.go

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