package server import ( "context" "encoding/json" "net/http" "regexp" "sort" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/access" "gitlab.com/Timfa/bluegit/internal/i18n" "gitlab.com/Timfa/bluegit/internal/store" "gitlab.com/Timfa/bluegit/internal/webhook" ) // Webhooks aanpassen en kopiƫren. Geheimen blijven server-side: het // token-veld is de naam van een geheim, en bij kopiƫren gaan ontbrekende // geheimen versleuteld mee naar het doel. Waarden komen nooit in een respons. func hookID(r *http.Request) (int64, error) { id, err := strconv.ParseInt(r.PathValue("id"), 10, 64) if err != nil || id <= 0 { return 0, fail(404, i18n.E("err.notFound")) } return id, nil } // inputOf geeft de opgeslagen invoer van een webhook terug. func inputOf(h store.Webhook) webhook.Input { d := draftFrom(h) return webhook.Input{ URL: d.URL, Username: d.Username, Avatar: d.Avatar, Icon: d.Icon, Alias: d.Alias, Token: d.Token, Chat: d.Chat, Server: d.Server, Topic: d.Topic, Homeserver: d.Home, Room: d.Room, Method: d.Method, ContentType: d.CType, Headers: d.Headers, Body: d.Body, } } // opPatchWebhook werkt alleen de meegestuurde velden bij. Een leeg of // weggelaten token houdt het bestaande geheim. func (s *Server) opPatchWebhook(ctx context.Context, user store.User, kind string, scopeID, id int64, raw map[string]json.RawMessage) (store.Webhook, error) { if err := s.manageScope(ctx, user, kind, scopeID); err != nil { return store.Webhook{}, err } h, err := s.Store.Webhook(ctx, kind, scopeID, id) if err != nil { return store.Webhook{}, fail(404, i18n.E("err.notFound")) } in := inputOf(h) name, preset, filter, events := h.Name, h.Preset, h.BranchFilter, h.Events str := func(key string, dst *string, keepEmpty bool) error { v, ok := raw[key] if !ok { return nil } var sv string if err := json.Unmarshal(v, &sv); err != nil { return fail(400, i18n.E("err.json")) } if keepEmpty && strings.TrimSpace(sv) == "" { return nil } *dst = sv return nil } fields := []struct { key string dst *string keep bool }{ {"name", &name, true}, {"preset", &preset, true}, {"branch_filter", &filter, false}, {"url", &in.URL, true}, {"username", &in.Username, false}, {"avatar", &in.Avatar, false}, {"icon", &in.Icon, false}, {"alias", &in.Alias, false}, {"token", &in.Token, true}, {"chat", &in.Chat, false}, {"server", &in.Server, false}, {"topic", &in.Topic, false}, {"homeserver", &in.Homeserver, false}, {"room", &in.Room, false}, {"method", &in.Method, true}, {"content_type", &in.ContentType, false}, {"headers", &in.Headers, true}, {"body", &in.Body, false}, } for _, f := range fields { if err := str(f.key, f.dst, f.keep); err != nil { return store.Webhook{}, err } } if v, ok := raw["events"]; ok { var ev []string if err := json.Unmarshal(v, &ev); err != nil { return store.Webhook{}, fail(400, i18n.E("err.json")) } events = ev } if _, err := s.saveWebhookRecord(ctx, kind, scopeID, id, strings.TrimSpace(name), preset, filter, events, in); err != nil { if store.Missing(err) { return store.Webhook{}, fail(404, i18n.E("err.notFound")) } return store.Webhook{}, fail(400, err) } if v, ok := raw["active"]; ok { var on bool if json.Unmarshal(v, &on) == nil { _ = s.Store.SetWebhookActive(ctx, kind, scopeID, id, on) } } return s.Store.Webhook(ctx, kind, scopeID, id) } var secretRefRe = regexp.MustCompile(`\{\{\s*secret\.([A-Za-z_][A-Za-z0-9_]*)\s*\}\}`) // hookSecretRefs geeft de geheimnamen die een webhook gebruikt. func hookSecretRefs(h store.Webhook) []string { seen := map[string]bool{} add := func(s string) { for _, m := range secretRefRe.FindAllStringSubmatch(s, -1) { seen[m[1]] = true } } add(h.URLTemplate) add(h.BodyTemplate) for k, v := range h.Headers { add(k) add(v) } out := make([]string, 0, len(seen)) for k := range seen { out = append(out, k) } sort.Strings(out) return out } type scopeRef struct { Kind string ID int64 } // secretScopes geeft de scopes waaruit een webhook geheimen leest, eigen scope eerst. func (s *Server) secretScopes(ctx context.Context, kind string, id int64) []scopeRef { out := []scopeRef{{kind, id}} if kind == "repo" { if repo, err := s.Store.RepoByID(ctx, id); err == nil && repo.OwnerKind == "group" { out = append(out, scopeRef{"group", repo.OwnerID}) } } return out } func (s *Server) secretNames(ctx context.Context, sc scopeRef) map[string]bool { out := map[string]bool{} list, _ := s.Store.ListSecrets(ctx, sc.Kind, sc.ID) for _, m := range list { out[m.Name] = true } return out } // CopyTarget is het doel van een kopie. type CopyTarget struct { Type string `json:"target_type"` // project of group Target string `json:"target"` // eigenaar/project of groepspad Name string `json:"name"` Events []string `json:"events"` } // HookCopyResult vertelt wat er gekopieerd is, zonder waarden. type HookCopyResult struct { Hook store.Webhook CopiedSecrets []string MissingSecrets []string } func (s *Server) resolveTarget(ctx context.Context, t CopyTarget) (string, int64, error) { path := strings.Trim(strings.TrimSpace(t.Target), "/") switch strings.ToLower(strings.TrimSpace(t.Type)) { case "project", "repo": i := strings.LastIndex(path, "/") if i <= 0 { return "", 0, fail(404, i18n.E("err.notFound")) } repo, err := s.Store.RepoByPath(ctx, path[:i], path[i+1:]) if err != nil { return "", 0, fail(404, i18n.E("err.notFound")) } return "repo", repo.ID, nil case "group": g, err := s.Store.GroupByPath(ctx, path) if err != nil { return "", 0, fail(404, i18n.E("err.notFound")) } return "group", g.ID, nil } return "", 0, fail(400, i18n.E("err.scope")) } // opCopyWebhook kopieert een webhook met geheimen naar een ander project of // een andere groep. Beide scopes vragen beheerrechten. func (s *Server) opCopyWebhook(ctx context.Context, user store.User, kind string, scopeID, id int64, t CopyTarget) (HookCopyResult, error) { if err := s.manageScope(ctx, user, kind, scopeID); err != nil { return HookCopyResult{}, err } h, err := s.Store.Webhook(ctx, kind, scopeID, id) if err != nil { return HookCopyResult{}, fail(404, i18n.E("err.notFound")) } tKind, tID, err := s.resolveTarget(ctx, t) if err != nil { return HookCopyResult{}, err } if err := s.manageScope(ctx, user, tKind, tID); err != nil { if oe, ok := err.(*opError); ok && oe.status == 403 { return HookCopyResult{}, fail(404, i18n.E("err.notFound")) } return HookCopyResult{}, err } if tKind == kind && tID == scopeID && strings.TrimSpace(t.Name) == "" { t.Name = h.Name + " (2)" } nh := h nh.ID, nh.ScopeKind, nh.ScopeID = 0, tKind, tID if n := strings.TrimSpace(t.Name); n != "" { nh.Name = n } if t.Events != nil { if len(t.Events) == 0 { return HookCopyResult{}, fail(400, i18n.E("err.pickEvent")) } nh.Events = t.Events } var res HookCopyResult src := s.secretScopes(ctx, kind, scopeID) dst := s.secretScopes(ctx, tKind, tID) srcNames := make([]map[string]bool, len(src)) for i, sc := range src { srcNames[i] = s.secretNames(ctx, sc) } dstNames := map[string]bool{} for _, sc := range dst { for k := range s.secretNames(ctx, sc) { dstNames[k] = true } } type plan struct { from scopeRef name string } var todo []plan for _, name := range hookSecretRefs(h) { if dstNames[name] { continue } found := false for i, sc := range src { if srcNames[i][name] { todo = append(todo, plan{sc, name}) found = true break } } if !found { res.MissingSecrets = append(res.MissingSecrets, name) } } for _, p := range todo { if err := s.Store.CopySecret(ctx, p.from.Kind, p.from.ID, p.name, tKind, tID); err != nil { return HookCopyResult{}, fail(400, err) } res.CopiedSecrets = append(res.CopiedSecrets, p.name) } nid, err := s.Store.CreateWebhook(ctx, nh) if err != nil { return HookCopyResult{}, fail(400, err) } if !h.Active { _ = s.Store.SetWebhookActive(ctx, tKind, tID, nid, false) } res.Hook, err = s.Store.Webhook(ctx, tKind, tID, nid) if err != nil { return HookCopyResult{}, fail(500, err) } return res, nil } // --- API --- func (s *Server) apiPatchHook(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) { id, err := hookID(r) if !s.apiOK(w, r, err) { return } raw := map[string]json.RawMessage{} if err := readJSON(r, &raw); err != nil { s.writeAPIErr(w, r, fail(400, i18n.E("err.json"))) return } h, err := s.opPatchWebhook(r.Context(), apiUser(r), kind, scopeID, id, raw) if !s.apiOK(w, r, err) { return } writeJSON(w, http.StatusOK, hookJSON(h)) } func (s *Server) apiCopyHook(w http.ResponseWriter, r *http.Request, kind string, scopeID int64) { id, err := hookID(r) if !s.apiOK(w, r, err) { return } var t CopyTarget if err := readJSON(r, &t); err != nil { s.writeAPIErr(w, r, fail(400, i18n.E("err.json"))) return } res, err := s.opCopyWebhook(r.Context(), apiUser(r), kind, scopeID, id, t) if !s.apiOK(w, r, err) { return } out := hookJSON(res.Hook) out["scope"] = res.Hook.ScopeKind out["copied_secrets"] = hookNames(res.CopiedSecrets) out["missing_secrets"] = hookNames(res.MissingSecrets) writeJSON(w, http.StatusCreated, out) } func hookNames(in []string) []string { if in == nil { return []string{} } return in } func (s *Server) apiPatchGroupHook(w http.ResponseWriter, r *http.Request) { g, ok := s.apiGroup(w, r, access.RoleMaintainer) if !ok { return } s.apiPatchHook(w, r, "group", g.ID) } func (s *Server) apiPatchProjectHook(w http.ResponseWriter, r *http.Request) { repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer) if !ok { return } s.apiPatchHook(w, r, "repo", repo.ID) } func (s *Server) apiCopyGroupHook(w http.ResponseWriter, r *http.Request) { g, ok := s.apiGroup(w, r, access.RoleMaintainer) if !ok { return } s.apiCopyHook(w, r, "group", g.ID) } func (s *Server) apiCopyProjectHook(w http.ResponseWriter, r *http.Request) { repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer) if !ok { return } s.apiCopyHook(w, r, "repo", repo.ID) } // --- UI --- // HookTarget is een keuze in het kopieervenster. type HookTarget struct { Value string Label string Group bool } // hookTargets geeft projecten en groepen die deze gebruiker beheert. func (s *Server) hookTargets(r *http.Request) []HookTarget { p := s.who(r) if !p.OK { return nil } ctx := r.Context() var out []HookTarget groups, _ := s.Store.ListGroups(ctx, p.User.ID) for _, g := range groups { if s.manageScope(ctx, p.User, "group", g.ID) == nil { out = append(out, HookTarget{Value: "group:" + g.Path, Label: g.Path, Group: true}) } } ids, _ := s.Store.ListRepoIDs(ctx, p.User.ID) var repos []HookTarget for _, id := range ids { if s.manageScope(ctx, p.User, "repo", id) != nil { continue } repo, err := s.Store.RepoByID(ctx, id) if err != nil { continue } repos = append(repos, HookTarget{Value: "project:" + repo.FullPath(), Label: repo.FullPath()}) } sort.Slice(repos, func(i, j int) bool { return repos[i].Label < repos[j].Label }) return append(out, repos...) } func (s *Server) repoWebhookCopy(w http.ResponseWriter, r *http.Request) { s.webhookCopy(w, r, "repo") } func (s *Server) groupWebhookCopy(w http.ResponseWriter, r *http.Request) { s.webhookCopy(w, r, "group") } func (s *Server) webhookCopy(w http.ResponseWriter, r *http.Request, kind string) { scopeID, back, ok := s.adminScope(w, r, kind) if !ok || !s.csrfOK(w, r) { return } back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks") if kind == "group" { back += "#webhooks" } id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64) typ, target, _ := strings.Cut(r.FormValue("target"), ":") res, err := s.opCopyWebhook(r.Context(), s.who(r).User, kind, scopeID, id, CopyTarget{Type: typ, Target: target, Name: r.FormValue("name")}) if err != nil { s.redirect(w, r, back, "", s.trErr(r, err)) return } msg := s.tr(r, "flash.webhookCopied", target) if len(res.MissingSecrets) > 0 { msg += " " + s.tr(r, "wh.copyMissing", strings.Join(res.MissingSecrets, ", ")) } s.redirect(w, r, back, msg, "") }