// Package access bevat de rolregels van BlueGit. // Een repository hoort bij een gebruiker of een groep. Leden hebben // Readonly, Developer of Maintainer. De effectieve rol is de hoogste // van groepslidmaatschap, rechtstreeks repolidmaatschap en eigenaarschap. // Installatiebeheer is hier geen rol: dat geeft geen toegang tot // repositories, groepen of geheimen van anderen. package access import ( "path" "regexp" "strings" "gitlab.com/Timfa/bluegit/internal/i18n" ) // Role is een toegangsrol op een repository of groep. type Role string const ( RoleNone Role = "" RoleReadonly Role = "readonly" RoleDeveloper Role = "developer" RoleMaintainer Role = "maintainer" ) // ParseRole herkent de drie rollen. Leeg is geen rol. func ParseRole(s string) (Role, error) { switch Role(strings.ToLower(strings.TrimSpace(s))) { case RoleReadonly: return RoleReadonly, nil case RoleDeveloper: return RoleDeveloper, nil case RoleMaintainer: return RoleMaintainer, nil case RoleNone: return RoleNone, i18n.E("err.roleMissing") default: return RoleNone, i18n.E("err.roleUnknown", s) } } // Label is de Engelse naam. De webinterface vertaalt via i18n. func (r Role) Label() string { switch r { case RoleReadonly: return "Readonly" case RoleDeveloper: return "Developer" case RoleMaintainer: return "Maintainer" default: return "None" } } // Rank geeft een volgorde. Hoger mag meer. func (r Role) Rank() int { switch r { case RoleReadonly: return 1 case RoleDeveloper: return 2 case RoleMaintainer: return 3 default: return 0 } } // Max geeft de hoogste van twee rollen. func Max(a, b Role) Role { if a.Rank() >= b.Rank() { return a } return b } // AtLeast meldt of de rol minstens other is. func (r Role) AtLeast(other Role) bool { return r.Rank() >= other.Rank() } // CanRead geldt voor elke echte rol. func (r Role) CanRead() bool { return r.AtLeast(RoleReadonly) } // CanWriteCode geldt voor ontwikkelaar en beheerder. // Protected branches en secrets vallen hier buiten. func (r Role) CanWriteCode() bool { return r.AtLeast(RoleDeveloper) } // CanManageSecrets geldt alleen voor een beheerder. func (r Role) CanManageSecrets() bool { return r.AtLeast(RoleMaintainer) } // CanManageSettings dekt leden, webhooks, beschermde branches en tags, en verwijderen. func (r Role) CanManageSettings() bool { return r.AtLeast(RoleMaintainer) } // CanPushBranch meldt of deze rol naar een branch mag schrijven. // protected is waar als de branch op een beschermd patroon past. func (r Role) CanPushBranch(protected bool) bool { if protected { return r.CanManageSettings() } return r.CanWriteCode() } // CanMerge meldt of deze rol een merge request naar target mag samenvoegen. func (r Role) CanMerge(targetProtected bool) bool { return r.CanPushBranch(targetProtected) } // Input is alles wat meespeelt bij de effectieve rol op één repository. // Installatiebeheer zit hier bewust niet in. type Input struct { // UserOwner is waar als de repository van deze gebruiker zelf is. UserOwner bool // GroupRole is de rol in de groep die de repository bezit. Leeg als // de repository niet van een groep is of de gebruiker geen lid is. GroupRole Role // RepoRole is een rechtstreeks lidmaatschap op de repository. RepoRole Role } // Resolve kiest de effectieve rol. // De persoonlijke eigenaar is beheerder. Een groepsbeheerder blijft // beheerder van elke repository van de groep. Een expliciete // repositoryrol vervangt een lagere groepsrol, zodat de standaardrol // van de groep op een nieuwe repository kan gelden. Zonder // repositoryrol blijft de groepsrol van kracht. func Resolve(in Input) Role { if in.UserOwner { return RoleMaintainer } if in.GroupRole == RoleMaintainer { return RoleMaintainer } if in.RepoRole != RoleNone { return in.RepoRole } return in.GroupRole } // BranchProtected meldt of branch op een van de patronen past. // Een patroon is exact, of een glob waarin * één padsegment is // (path.Match). "release/*" past dus op "release/1.2" en niet op // "release/1.2/rc". func BranchProtected(patterns []string, branch string) bool { for _, p := range patterns { p = strings.TrimSpace(p) if p == "" { continue } if p == branch { return true } ok, err := path.Match(p, branch) if err == nil && ok { return true } } return false } // RefUpdate is één regel uit een pre-receive-hook. type RefUpdate struct { Old string New string Ref string } // AuthorizeUpdate keurt één ref-update goed of af. // Een beschermde branch of een tag die op een beschermd patroon past // mag alleen een beheerder schrijven. Alleen-lezen mag niets schrijven. func AuthorizeUpdate(role Role, patterns, tagPatterns []string, u RefUpdate) error { if !role.CanWriteCode() { return i18n.E("err.hook.nowrite", u.Ref) } const tags = "refs/tags/" if strings.HasPrefix(u.Ref, tags) { name := strings.TrimPrefix(u.Ref, tags) if name == "" || strings.HasPrefix(name, "-") || strings.HasPrefix(name, "/") || strings.HasSuffix(name, "/") || strings.Contains(name, "..") { return i18n.E("err.tag", name) } if BranchProtected(tagPatterns, name) && !role.CanManageSettings() { return i18n.E("err.hook.tag", name) } return nil } const heads = "refs/heads/" if !strings.HasPrefix(u.Ref, heads) { return nil } branch := strings.TrimPrefix(u.Ref, heads) if branch == "" || strings.Contains(branch, "..") { return i18n.E("err.hook.branch", branch) } if BranchProtected(patterns, branch) && !role.CanPushBranch(true) { return i18n.E("err.hook.protected", branch) } return nil } // AuthorizeUpdates keurt een hele push goed. De eerste fout stopt. func AuthorizeUpdates(role Role, patterns, tagPatterns []string, updates []RefUpdate) error { if len(updates) == 0 { return i18n.E("err.hook.empty") } for _, u := range updates { if err := AuthorizeUpdate(role, patterns, tagPatterns, u); err != nil { return err } } return nil } // InjectSecret meldt of een CI-job dit geheim als omgevingsvariabele krijgt. // Een beschermd geheim gaat alleen mee als de pipeline op een beschermde // branch draait. Onbeschermde geheimen gaan met elke job mee. // Dit is onafhankelijk van de UI: een ontwikkelaar leest geheimen nooit // terug, ook al belanden ze in een job die zijn pipeline startte. func InjectSecret(secretProtected, refProtected bool) bool { if secretProtected { return refProtected } return true } // secretNameRE is dezelfde vorm als een GitLab-variabele: een letter of // underscore, daarna letters, cijfers en underscores. Hoofdletters en // kleine letters zijn allebei geldig. var secretNameRE = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`) // ValidSecretName eist een omgevingsvariabelenaam. func ValidSecretName(name string) error { if name == "" || len(name) > 80 { return i18n.E("err.secretLen") } if !secretNameRE.MatchString(name) { return i18n.E("err.secretForm", name) } return nil }