BlueGit

timfa bluegit

Files

bluegit / internal / server / secret_api.go

secret_api.go

secret_api.go 7.0 KiB Download Raw
1package server
2
3import (
4 "encoding/json"
5 "io"
6 "net/http"
7 "strings"
8 "time"
9
10 "gitlab.com/Timfa/bluegit/internal/store"
11)
12
13type secretBody struct {
14 Name string `json:"name"`
15 Value string `json:"value"`
16 Protected bool `json:"protected"`
17 Invisible bool `json:"invisible"`
18 Expand *bool `json:"expand"`
19}
20
21func (s *Server) repoSecretsAPI(w http.ResponseWriter, r *http.Request) {
22 repo, _, ok := s.secretAPIRepo(w, r)
23 if !ok {
24 return
25 }
26 s.secretListAPI(w, r, "repo", repo.ID)
27}
28
29func (s *Server) groupSecretsAPI(w http.ResponseWriter, r *http.Request) {
30 g, _, ok := s.secretAPIGroup(w, r)
31 if !ok {
32 return
33 }
34 s.secretListAPI(w, r, "group", g.ID)
35}
36
37func (s *Server) repoSecretCreateAPI(w http.ResponseWriter, r *http.Request) {
38 repo, _, ok := s.secretAPIRepo(w, r)
39 if !ok {
40 return
41 }
42 s.secretWriteAPI(w, r, "repo", repo.ID, "create")
43}
44
45func (s *Server) groupSecretCreateAPI(w http.ResponseWriter, r *http.Request) {
46 g, _, ok := s.secretAPIGroup(w, r)
47 if !ok {
48 return
49 }
50 s.secretWriteAPI(w, r, "group", g.ID, "create")
51}
52
53func (s *Server) repoSecretRevealAPI(w http.ResponseWriter, r *http.Request) {
54 repo, _, ok := s.secretAPIRepo(w, r)
55 if !ok {
56 return
57 }
58 s.secretRevealAPI(w, r, "repo", repo.ID)
59}
60
61func (s *Server) groupSecretRevealAPI(w http.ResponseWriter, r *http.Request) {
62 g, _, ok := s.secretAPIGroup(w, r)
63 if !ok {
64 return
65 }
66 s.secretRevealAPI(w, r, "group", g.ID)
67}
68
69func (s *Server) repoSecretUpdateAPI(w http.ResponseWriter, r *http.Request) {
70 repo, _, ok := s.secretAPIRepo(w, r)
71 if !ok {
72 return
73 }
74 s.secretWriteAPI(w, r, "repo", repo.ID, "update")
75}
76
77func (s *Server) groupSecretUpdateAPI(w http.ResponseWriter, r *http.Request) {
78 g, _, ok := s.secretAPIGroup(w, r)
79 if !ok {
80 return
81 }
82 s.secretWriteAPI(w, r, "group", g.ID, "update")
83}
84
85func (s *Server) repoSecretReplaceAPI(w http.ResponseWriter, r *http.Request) {
86 repo, _, ok := s.secretAPIRepo(w, r)
87 if !ok {
88 return
89 }
90 s.secretWriteAPI(w, r, "repo", repo.ID, "replace")
91}
92
93func (s *Server) groupSecretReplaceAPI(w http.ResponseWriter, r *http.Request) {
94 g, _, ok := s.secretAPIGroup(w, r)
95 if !ok {
96 return
97 }
98 s.secretWriteAPI(w, r, "group", g.ID, "replace")
99}
100
101func (s *Server) repoSecretDeleteAPI(w http.ResponseWriter, r *http.Request) {
102 repo, _, ok := s.secretAPIRepo(w, r)
103 if !ok {
104 return
105 }
106 s.secretDeleteAPI(w, r, "repo", repo.ID)
107}
108
109func (s *Server) groupSecretDeleteAPI(w http.ResponseWriter, r *http.Request) {
110 g, _, ok := s.secretAPIGroup(w, r)
111 if !ok {
112 return
113 }
114 s.secretDeleteAPI(w, r, "group", g.ID)
115}
116
117func (s *Server) secretAPIRepo(w http.ResponseWriter, r *http.Request) (store.Repo, store.User, bool) {
118 u, ok := s.webhookAPIUser(w, r)
119 if !ok {
120 return store.Repo{}, store.User{}, false
121 }
122 repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
123 if err != nil {
124 http.NotFound(w, r)
125 return store.Repo{}, store.User{}, false
126 }
127 role, err := s.Store.EffectiveRole(r.Context(), u.ID, repo.ID)
128 if err != nil || !role.CanManageSecrets() {
129 http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
130 return store.Repo{}, store.User{}, false
131 }
132 return repo, u, true
133}
134
135func (s *Server) secretAPIGroup(w http.ResponseWriter, r *http.Request) (store.Group, store.User, bool) {
136 u, ok := s.webhookAPIUser(w, r)
137 if !ok {
138 return store.Group{}, store.User{}, false
139 }
140 g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))
141 if err != nil {
142 http.NotFound(w, r)
143 return store.Group{}, store.User{}, false
144 }
145 role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
146 if err != nil || !role.CanManageSecrets() {
147 http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
148 return store.Group{}, store.User{}, false
149 }
150 return g, u, true
151}
152
153func (s *Server) secretListAPI(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) {
154 list, err := s.Store.ListSecrets(r.Context(), kind, scopeID)
155 if err != nil {
156 http.Error(w, s.trErr(r, err), http.StatusInternalServerError)
157 return
158 }
159 out := make([]map[string]any, 0, len(list))
160 for _, m := range list {
161 out = append(out, secretMetaJSON(m))
162 }
163 resp := map[string]any{"secrets": out}
164 if kind == "repo" {
165 if repo, err := s.Store.RepoByID(r.Context(), scopeID); err == nil {
166 resp["inherited"] = inheritedJSON(s.inheritedSecrets(r.Context(), repo))
167 }
168 }
169 w.Header().Set("Content-Type", "application/json")
170 _ = json.NewEncoder(w).Encode(resp)
171}
172
173func (s *Server) secretWriteAPI(w http.ResponseWriter, r *http.Request, kind string, scopeID int64, mode string) {
174 var body secretBody
175 if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&body); err != nil {
176 http.Error(w, s.tr(r, "err.json"), http.StatusBadRequest)
177 return
178 }
179 name := strings.TrimSpace(body.Name)
180 if mode != "create" {
181 name = strings.TrimSpace(r.PathValue("name"))
182 }
183 var err error
184 switch mode {
185 case "update":
186 err = s.Store.UpdateSecret(r.Context(), kind, scopeID, name, body.Value, body.Protected)
187 case "replace":
188 err = s.Store.ReplaceSecret(r.Context(), kind, scopeID, name, body.Value, body.Protected)
189 default:
190 err = s.Store.CreateSecret(r.Context(), kind, scopeID, name, body.Value, body.Protected, body.Invisible)
191 }
192 if err != nil {
193 s.writeSecretErr(w, r, err)
194 return
195 }
196 if body.Expand != nil {
197 _ = s.Store.SetSecretExpand(r.Context(), kind, scopeID, name, *body.Expand)
198 }
199 meta, err := s.secretMeta(r, kind, scopeID, name)
200 if err != nil {
201 s.writeSecretErr(w, r, err)
202 return
203 }
204 w.Header().Set("Content-Type", "application/json")
205 if mode == "create" {
206 w.WriteHeader(http.StatusCreated)
207 }
208 _ = json.NewEncoder(w).Encode(secretMetaJSON(meta))
209}
210
211func (s *Server) secretRevealAPI(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) {
212 name := strings.TrimSpace(r.PathValue("name"))
213 value, err := s.Store.RevealSecret(r.Context(), kind, scopeID, name)
214 if err != nil {
215 s.writeSecretErr(w, r, err)
216 return
217 }
218 w.Header().Set("Content-Type", "application/json")
219 _ = json.NewEncoder(w).Encode(map[string]string{"name": name, "value": value})
220}
221
222func (s *Server) secretDeleteAPI(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) {
223 if err := s.Store.DeleteSecret(r.Context(), kind, scopeID, strings.TrimSpace(r.PathValue("name"))); err != nil {
224 s.writeSecretErr(w, r, err)
225 return
226 }
227 w.WriteHeader(http.StatusNoContent)
228}
229
230func (s *Server) secretMeta(r *http.Request, kind string, scopeID int64, name string) (store.SecretMeta, error) {
231 list, err := s.Store.ListSecrets(r.Context(), kind, scopeID)
232 if err != nil {
233 return store.SecretMeta{}, err
234 }
235 for _, m := range list {
236 if m.Name == name {
237 return m, nil
238 }
239 }
240 return store.SecretMeta{}, store.NotFound()
241}
242
243func secretMetaJSON(m store.SecretMeta) map[string]any {
244 created := ""
245 if !m.CreatedAt.IsZero() {
246 created = m.CreatedAt.UTC().Format(time.RFC3339)
247 }
248 return map[string]any{
249 "name": m.Name,
250 "protected": m.Protected,
251 "invisible": m.Invisible,
252 "expand": m.Expand,
253 "created_at": created,
254 }
255}
256
257func (s *Server) writeSecretErr(w http.ResponseWriter, r *http.Request, err error) {
258 http.Error(w, s.trErr(r, err), secretStatus(err))
259}