BlueGit

timfa bluegit

Files

bluegit / internal / access / access.go

access.go

feat: sta gemengde secretnamen toe en kies ze bij een webhook
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
c102b10c History
access.go 6.8 KiB Download Raw
1// Package access bevat de rolregels van BlueGit.
2// Een repository hoort bij een gebruiker of een groep. Leden hebben
3// Readonly, Developer of Maintainer. De effectieve rol is de hoogste
4// van groepslidmaatschap, rechtstreeks repolidmaatschap en eigenaarschap.
5// Installatiebeheer is hier geen rol: dat geeft geen toegang tot
6// repositories, groepen of geheimen van anderen.
7package access
8
9import (
10 "path"
11 "regexp"
12 "strings"
13
14 "gitlab.com/Timfa/bluegit/internal/i18n"
15)
16
17// Role is een toegangsrol op een repository of groep.
18type Role string
19
20const (
21 RoleNone Role = ""
22 RoleReadonly Role = "readonly"
23 RoleDeveloper Role = "developer"
24 RoleMaintainer Role = "maintainer"
25)
26
27// ParseRole herkent de drie rollen. Leeg is geen rol.
28func ParseRole(s string) (Role, error) {
29 switch Role(strings.ToLower(strings.TrimSpace(s))) {
30 case RoleReadonly:
31 return RoleReadonly, nil
32 case RoleDeveloper:
33 return RoleDeveloper, nil
34 case RoleMaintainer:
35 return RoleMaintainer, nil
36 case RoleNone:
37 return RoleNone, i18n.E("err.roleMissing")
38 default:
39 return RoleNone, i18n.E("err.roleUnknown", s)
40 }
41}
42
43// Label is de Engelse naam. De webinterface vertaalt via i18n.
44func (r Role) Label() string {
45 switch r {
46 case RoleReadonly:
47 return "Readonly"
48 case RoleDeveloper:
49 return "Developer"
50 case RoleMaintainer:
51 return "Maintainer"
52 default:
53 return "None"
54 }
55}
56
57// Rank geeft een volgorde. Hoger mag meer.
58func (r Role) Rank() int {
59 switch r {
60 case RoleReadonly:
61 return 1
62 case RoleDeveloper:
63 return 2
64 case RoleMaintainer:
65 return 3
66 default:
67 return 0
68 }
69}
70
71// Max geeft de hoogste van twee rollen.
72func Max(a, b Role) Role {
73 if a.Rank() >= b.Rank() {
74 return a
75 }
76 return b
77}
78
79// AtLeast meldt of de rol minstens other is.
80func (r Role) AtLeast(other Role) bool {
81 return r.Rank() >= other.Rank()
82}
83
84// CanRead geldt voor elke echte rol.
85func (r Role) CanRead() bool { return r.AtLeast(RoleReadonly) }
86
87// CanWriteCode geldt voor ontwikkelaar en beheerder.
88// Protected branches en secrets vallen hier buiten.
89func (r Role) CanWriteCode() bool { return r.AtLeast(RoleDeveloper) }
90
91// CanManageSecrets geldt alleen voor een beheerder.
92func (r Role) CanManageSecrets() bool { return r.AtLeast(RoleMaintainer) }
93
94// CanManageSettings dekt leden, webhooks, beschermde branches en tags, en verwijderen.
95func (r Role) CanManageSettings() bool { return r.AtLeast(RoleMaintainer) }
96
97// CanPushBranch meldt of deze rol naar een branch mag schrijven.
98// protected is waar als de branch op een beschermd patroon past.
99func (r Role) CanPushBranch(protected bool) bool {
100 if protected {
101 return r.CanManageSettings()
102 }
103 return r.CanWriteCode()
104}
105
106// CanMerge meldt of deze rol een merge request naar target mag samenvoegen.
107func (r Role) CanMerge(targetProtected bool) bool {
108 return r.CanPushBranch(targetProtected)
109}
110
111// Input is alles wat meespeelt bij de effectieve rol op één repository.
112// Installatiebeheer zit hier bewust niet in.
113type Input struct {
114 // UserOwner is waar als de repository van deze gebruiker zelf is.
115 UserOwner bool
116 // GroupRole is de rol in de groep die de repository bezit. Leeg als
117 // de repository niet van een groep is of de gebruiker geen lid is.
118 GroupRole Role
119 // RepoRole is een rechtstreeks lidmaatschap op de repository.
120 RepoRole Role
121}
122
123// Resolve kiest de effectieve rol.
124// De persoonlijke eigenaar is beheerder. Een groepsbeheerder blijft
125// beheerder van elke repository van de groep. Een expliciete
126// repositoryrol vervangt een lagere groepsrol, zodat de standaardrol
127// van de groep op een nieuwe repository kan gelden. Zonder
128// repositoryrol blijft de groepsrol van kracht.
129func Resolve(in Input) Role {
130 if in.UserOwner {
131 return RoleMaintainer
132 }
133 if in.GroupRole == RoleMaintainer {
134 return RoleMaintainer
135 }
136 if in.RepoRole != RoleNone {
137 return in.RepoRole
138 }
139 return in.GroupRole
140}
141
142// BranchProtected meldt of branch op een van de patronen past.
143// Een patroon is exact, of een glob waarin * één padsegment is
144// (path.Match). "release/*" past dus op "release/1.2" en niet op
145// "release/1.2/rc".
146func BranchProtected(patterns []string, branch string) bool {
147 for _, p := range patterns {
148 p = strings.TrimSpace(p)
149 if p == "" {
150 continue
151 }
152 if p == branch {
153 return true
154 }
155 ok, err := path.Match(p, branch)
156 if err == nil && ok {
157 return true
158 }
159 }
160 return false
161}
162
163// RefUpdate is één regel uit een pre-receive-hook.
164type RefUpdate struct {
165 Old string
166 New string
167 Ref string
168}
169
170// AuthorizeUpdate keurt één ref-update goed of af.
171// Een beschermde branch of een tag die op een beschermd patroon past
172// mag alleen een beheerder schrijven. Alleen-lezen mag niets schrijven.
173func AuthorizeUpdate(role Role, patterns, tagPatterns []string, u RefUpdate) error {
174 if !role.CanWriteCode() {
175 return i18n.E("err.hook.nowrite", u.Ref)
176 }
177 const tags = "refs/tags/"
178 if strings.HasPrefix(u.Ref, tags) {
179 name := strings.TrimPrefix(u.Ref, tags)
180 if name == "" || strings.HasPrefix(name, "-") || strings.HasPrefix(name, "/") || strings.HasSuffix(name, "/") || strings.Contains(name, "..") {
181 return i18n.E("err.tag", name)
182 }
183 if BranchProtected(tagPatterns, name) && !role.CanManageSettings() {
184 return i18n.E("err.hook.tag", name)
185 }
186 return nil
187 }
188 const heads = "refs/heads/"
189 if !strings.HasPrefix(u.Ref, heads) {
190 return nil
191 }
192 branch := strings.TrimPrefix(u.Ref, heads)
193 if branch == "" || strings.Contains(branch, "..") {
194 return i18n.E("err.hook.branch", branch)
195 }
196 if BranchProtected(patterns, branch) && !role.CanPushBranch(true) {
197 return i18n.E("err.hook.protected", branch)
198 }
199 return nil
200}
201
202// AuthorizeUpdates keurt een hele push goed. De eerste fout stopt.
203func AuthorizeUpdates(role Role, patterns, tagPatterns []string, updates []RefUpdate) error {
204 if len(updates) == 0 {
205 return i18n.E("err.hook.empty")
206 }
207 for _, u := range updates {
208 if err := AuthorizeUpdate(role, patterns, tagPatterns, u); err != nil {
209 return err
210 }
211 }
212 return nil
213}
214
215// InjectSecret meldt of een CI-job dit geheim als omgevingsvariabele krijgt.
216// Een beschermd geheim gaat alleen mee als de pipeline op een beschermde
217// branch draait. Onbeschermde geheimen gaan met elke job mee.
218// Dit is onafhankelijk van de UI: een ontwikkelaar leest geheimen nooit
219// terug, ook al belanden ze in een job die zijn pipeline startte.
220func InjectSecret(secretProtected, refProtected bool) bool {
221 if secretProtected {
222 return refProtected
223 }
224 return true
225}
226
227// secretNameRE is dezelfde vorm als een GitLab-variabele: een letter of
228// underscore, daarna letters, cijfers en underscores. Hoofdletters en
229// kleine letters zijn allebei geldig.
230var secretNameRE = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
231
232// ValidSecretName eist een omgevingsvariabelenaam.
233func ValidSecretName(name string) error {
234 if name == "" || len(name) > 80 {
235 return i18n.E("err.secretLen")
236 }
237 if !secretNameRE.MatchString(name) {
238 return i18n.E("err.secretForm", name)
239 }
240 return nil
241}