package group import ( "encoding/json" "errors" "fmt" "io/fs" "log" "os" "path" "path/filepath" "strings" "time" "github.com/jech/galene/token" ) var ErrTagMismatch = errors.New("tag mismatch") var ErrDescriptionsNotWritable = &NotAuthorisedError{} type Permissions struct { // non-empty for a named permissions set name string // only used when unnamed permissions []string } var permissionsMap = map[string][]string{ "op": {"op", "present", "message", "token"}, "present": {"present", "message"}, "message": {"message"}, "observe": {}, "admin": {"admin"}, } func NewPermissions(name string) (Permissions, error) { _, ok := permissionsMap[name] if !ok { return Permissions{}, errors.New("unknown permission") } return Permissions{ name: name, }, nil } func (p Permissions) Permissions(desc *Description) []string { if p.name == "" { return p.permissions } perms := permissionsMap[p.name] op := false present := false token := false record := false for _, p := range perms { switch p { case "op": op = true case "present": present = true case "token": token = true case "record": record = true } } if desc != nil && desc.AllowRecording { if op && !record { // copy the slice perms = append([]string{"record"}, perms...) } } if desc != nil && desc.UnrestrictedTokens { if present && !token { perms = append([]string{"token"}, perms...) } } return perms } func (p *Permissions) UnmarshalJSON(b []byte) error { var a []string err := json.Unmarshal(b, &a) if err == nil { *p = Permissions{ permissions: a, } return nil } var s string err = json.Unmarshal(b, &s) if err == nil { _, ok := permissionsMap[s] if !ok { return errors.New("Unknown permission " + s) } *p = Permissions{ name: s, } return nil } return err } func (p Permissions) MarshalJSON() ([]byte, error) { if p.name != "" { return json.Marshal(p.name) } return json.Marshal(p.permissions) } type UserDescription struct { Password Password `json:"password"` Permissions Permissions `json:"permissions"` } // Custom MarshalJSON in order to omit ompty fields func (u UserDescription) MarshalJSON() ([]byte, error) { uu := make(map[string]any, 2) if u.Password.Type != "" { uu["password"] = &u.Password } if u.Permissions.name != "" || u.Permissions.permissions != nil { uu["permissions"] = &u.Permissions } return json.Marshal(uu) } // Description represents a group description together with some metadata // about the JSON file it was deserialised from. type Description struct { // The file this was deserialised from. This is not necessarily // the name of the group, for example in case of a subgroup. FileName string `json:"-"` // The modtime and size of the file. These are used to detect // when a file has changed on disk. modTime time.Time `json:"-"` fileSize int64 `json:"-"` // Whether this is an automatically generated subgroup isSubgroup bool `json:"-"` // The user-friendly group name DisplayName string `json:"displayName,omitempty"` // A user-readable description of the group. Description string `json:"description,omitempty"` // A user-readable contact, typically an e-mail address. Contact string `json:"contact,omitempty"` // A user-readable comment. Ignored by the server. Comment string `json:"comment,omitempty"` // Whether to display the group on the landing page. Public bool `json:"public,omitempty"` // A URL to redirect the group to. If this is not empty, most // other fields are ignored. Redirect string `json:"redirect,omitempty"` // The maximum number of simultaneous clients. Unlimited if 0. MaxClients int `json:"max-clients,omitempty"` // The time for which history entries are kept. MaxHistoryAge int `json:"max-history-age,omitempty"` // Time after which joining is no longer allowed Expires *time.Time `json:"expires,omitempty"` // Time before which joining is not allowed NotBefore *time.Time `json:"not-before,omitempty"` // Whether recording is allowed. AllowRecording bool `json:"allow-recording,omitempty"` // Whether creating tokens is allowed UnrestrictedTokens bool `json:"unrestricted-tokens,omitempty"` // Whether subgroups are created on the fly. AutoSubgroups bool `json:"auto-subgroups,omitempty"` // Whether to lock the group when the last op logs out. Autolock bool `json:"autolock,omitempty"` // Whether to kick all users when the last op logs out. Autokick bool `json:"autokick,omitempty"` // Users allowed to login Users map[string]UserDescription `json:"users,omitempty"` // Credentials for user with arbitrary username WildcardUser *UserDescription `json:"wildcard-user,omitempty"` // The (public) keys used for token authentication. AuthKeys []map[string]interface{} `json:"authKeys,omitempty"` // The URL of the authentication server, if any. AuthServer string `json:"authServer,omitempty"` // The URL of the authentication portal, if any. AuthPortal string `json:"authPortal,omitempty"` // Codec preferences. If empty, a suitable default is chosen in // the APIFromNames function. Codecs []string `json:"codecs,omitempty"` // Obsolete fields Op []ClientPattern `json:"op,omitempty"` Presenter []ClientPattern `json:"presenter,omitempty"` Other []ClientPattern `json:"other,omitempty"` AllowSubgroups bool `json:"allow-subgroups,omitempty"` AllowAnonymous bool `json:"allow-anonymous,omitempty"` } const DefaultMaxHistoryAge = 4 * time.Hour func maxHistoryAge(desc *Description) time.Duration { if desc.MaxHistoryAge != 0 { return time.Duration(desc.MaxHistoryAge) * time.Second } return DefaultMaxHistoryAge } func getDescriptionFile[T any](name string, allowSubgroups bool, get func(string) (T, error)) (T, string, bool, error) { isSubgroup := false for name != "" { fileName := filepath.Join( Directory, path.Clean("/"+name)+".json", ) r, err := get(fileName) if !errors.Is(err, os.ErrNotExist) { return r, fileName, isSubgroup, err } if !allowSubgroups { break } isSubgroup = true name, _ = path.Split(name) name = strings.TrimRight(name, "/") } var zero T return zero, "", false, os.ErrNotExist } // descriptionMatch returns true if the description hasn't changed between // d1 and d2 func descriptionMatch(d1, d2 *Description) bool { if d1.FileName != d2.FileName { return false } if d1.fileSize != d2.fileSize || !d1.modTime.Equal(d2.modTime) { return false } return true } // descriptionUnchanged returns true if a group's description hasn't // changed since it was last read. func descriptionUnchanged(name string, desc *Description) bool { fi, fileName, _, err := getDescriptionFile(name, true, os.Stat) if err != nil || fileName != desc.FileName { return false } if fi.Size() != desc.fileSize || !fi.ModTime().Equal(desc.modTime) { return false } return true } // GetDescription gets a group description, either from cache or from disk func GetDescription(name string) (*Description, error) { g := Get(name) if g != nil { if descriptionUnchanged(name, g.description) { return g.description, nil } } return readDescription(name, true) } // GetSanitisedDescription returns the subset of the description that is // published on the web interface together with a suitable ETag. func GetSanitisedDescription(name string) (*Description, string, error) { d, err := GetDescription(name) if err != nil { return nil, "", err } if d.isSubgroup { return nil, "", os.ErrNotExist } desc := *d desc.Users = nil desc.WildcardUser = nil desc.AuthKeys = nil return &desc, makeETag(desc.fileSize, desc.modTime), nil } // GetDescriptionTag returns an ETag for a description. func GetDescriptionTag(name string) (string, error) { fi, _, _, err := getDescriptionFile(name, false, os.Stat) if err != nil { return "", err } return makeETag(fi.Size(), fi.ModTime()), nil } func makeETag(fileSize int64, modTime time.Time) string { return fmt.Sprintf("\"%v-%v\"", fileSize, modTime.UnixNano()) } // DeleteDescription deletes a description (and therefore persistently // deletes a group) but only if it matches a given ETag. func DeleteDescription(name, etag string) error { groups.mu.Lock() defer groups.mu.Unlock() fi, fileName, _, err := getDescriptionFile(name, false, os.Stat) if err != nil { return err } if etag != makeETag(fi.Size(), fi.ModTime()) { return ErrTagMismatch } return os.Remove(fileName) } // UpdateDescription overwrites a description if it matches a given ETag. // In order to create a new group, pass an empty ETag. func UpdateDescription(name, etag string, desc *Description) error { if desc.Users != nil || desc.WildcardUser != nil || desc.AuthKeys != nil { return errors.New("description is not sanitised") } groups.mu.Lock() defer groups.mu.Unlock() oldetag := "" var filename string old, err := readDescription(name, false) if err == nil { oldetag = makeETag(old.fileSize, old.modTime) filename = old.FileName } else if errors.Is(err, os.ErrNotExist) { old = nil filename = filepath.Join( Directory, path.Clean("/"+name)+".json", ) } else { return err } if oldetag != etag { return ErrTagMismatch } newdesc := *desc if old != nil { newdesc.Users = old.Users newdesc.WildcardUser = old.WildcardUser newdesc.AuthKeys = old.AuthKeys } return rewriteDescriptionFile(filename, &newdesc) } func rewriteDescriptionFile(filename string, desc *Description) error { conf, err := GetConfiguration() if err != nil { return err } if !conf.WritableGroups { return ErrDescriptionsNotWritable } dir := filepath.Dir(filename) err = os.MkdirAll(dir, 0700) if err != nil { return err } f, err := os.CreateTemp(dir, "*.temp") if err != nil { return err } temp := f.Name() encoder := json.NewEncoder(f) err = encoder.Encode(desc) if err == nil { err = f.Sync() } if err != nil { f.Close() os.Remove(temp) return err } err = f.Close() if err != nil { os.Remove(temp) return err } err = os.Rename(temp, filename) if err != nil { os.Remove(temp) return err } return nil } // readDescription reads a group's description from disk func readDescription(name string, allowSubgroups bool) (*Description, error) { r, fileName, isSubgroup, err := getDescriptionFile(name, allowSubgroups, os.Open) if err != nil { return nil, err } defer r.Close() var desc Description fi, err := r.Stat() if err != nil { return nil, err } d := json.NewDecoder(r) d.DisallowUnknownFields() err = d.Decode(&desc) if err != nil { return nil, err } desc.FileName = fileName desc.fileSize = fi.Size() desc.modTime = fi.ModTime() err = upgradeDescription(&desc) if err != nil { return nil, err } if isSubgroup { if !desc.AutoSubgroups { return nil, os.ErrNotExist } desc.isSubgroup = true desc.Public = false desc.Description = "" } return &desc, nil } func upgradeDescription(desc *Description) error { if desc.AllowAnonymous { log.Printf( "%v: field allow-anonymous is obsolete, ignored", desc.FileName, ) desc.AllowAnonymous = false } if desc.AllowSubgroups { desc.AutoSubgroups = true desc.AllowSubgroups = false } upgradePassword := func(pw *Password) Password { if pw == nil { return Password{ Type: "wildcard", } } return *pw } upgradeUser := func(u ClientPattern, p string) UserDescription { return UserDescription{ Password: upgradePassword(u.Password), Permissions: Permissions{ name: p, }, } } upgradeUsers := func(ps []ClientPattern, p string) { if desc.Users == nil { desc.Users = make(map[string]UserDescription) } for _, u := range ps { if u.Username == "" { if desc.WildcardUser != nil { log.Printf("%v: duplicate wildcard user", desc.FileName) continue } u := upgradeUser(u, p) desc.WildcardUser = &u continue } _, found := desc.Users[u.Username] if found { log.Printf("%v: duplicate user %v, ignored", desc.FileName, u.Username) continue } desc.Users[u.Username] = upgradeUser(u, p) } } if desc.Op != nil { upgradeUsers(desc.Op, "op") desc.Op = nil } if desc.Presenter != nil { upgradeUsers(desc.Presenter, "present") desc.Presenter = nil } if desc.Other != nil { upgradeUsers(desc.Other, "message") desc.Other = nil } return nil } func GetDescriptionNames() ([]string, error) { var names []string err := filepath.WalkDir( Directory, func(path string, d fs.DirEntry, err error) error { if err != nil { return nil } base := filepath.Base(path) if d.IsDir() { if base[0] == '.' { return fs.SkipDir } return nil } if base[0] == '.' { return nil } if strings.HasSuffix(base, ".json") { names = append(names, strings.TrimSuffix( base, ".json", )) } return nil }, ) return names, err } func SetKeys(group string, keys []map[string]any) error { if keys != nil { _, err := token.ParseKeys(keys, "", "") if err != nil { return err } } groups.mu.Lock() defer groups.mu.Unlock() desc, err := readDescription(group, false) if err != nil { return err } desc.AuthKeys = keys return rewriteDescriptionFile(desc.FileName, desc) } func GetUsers(group string) ([]string, string, error) { desc, err := GetDescription(group) if err != nil { return nil, "", err } users := make([]string, 0, len(desc.Users)) for u := range desc.Users { users = append(users, u) } return users, makeETag(desc.fileSize, desc.modTime), nil } func GetSanitisedUser(group, username string, wildcard bool) (UserDescription, string, error) { if wildcard && username != "" { return UserDescription{}, "", errors.New("wildcard with username") } desc, err := GetDescription(group) if err != nil { return UserDescription{}, "", err } var u UserDescription if wildcard { if desc.WildcardUser == nil { return UserDescription{}, "", os.ErrNotExist } u = *desc.WildcardUser } else { if desc.Users == nil { return UserDescription{}, "", os.ErrNotExist } ok := false u, ok = desc.Users[username] if !ok { return UserDescription{}, "", os.ErrNotExist } } u.Password = Password{} return u, makeETag(desc.fileSize, desc.modTime), nil } func GetUserTag(group, username string, wildcard bool) (string, error) { _, etag, err := GetSanitisedUser(group, username, wildcard) return etag, err } func DeleteUser(group, username string, wildcard bool, etag string) error { if wildcard && username != "" { return errors.New("wildcard with username") } groups.mu.Lock() defer groups.mu.Unlock() desc, err := readDescription(group, false) if err != nil { return err } if wildcard { if desc.WildcardUser == nil { return os.ErrNotExist } } else { if desc.Users == nil { return os.ErrNotExist } _, ok := desc.Users[username] if !ok { return os.ErrNotExist } } oldetag := makeETag(desc.fileSize, desc.modTime) if oldetag != etag { return ErrTagMismatch } if wildcard { desc.WildcardUser = nil } else { delete(desc.Users, username) } return rewriteDescriptionFile(desc.FileName, desc) } func UpdateUser(group, username string, wildcard bool, etag string, user *UserDescription) error { if wildcard && username != "" { return errors.New("wildcard with username") } if user.Password.Type != "" || user.Password.Key != nil { return errors.New("user description is not sanitised") } groups.mu.Lock() defer groups.mu.Unlock() desc, err := readDescription(group, false) if err != nil { return err } var old UserDescription var ok bool if wildcard { if desc.WildcardUser != nil { ok = true old = *desc.WildcardUser } } else { if desc.Users == nil { desc.Users = make(map[string]UserDescription) } old, ok = desc.Users[username] } var oldetag string if ok { oldetag = makeETag(desc.fileSize, desc.modTime) } else { oldetag = "" } if oldetag != etag { return ErrTagMismatch } newuser := *user newuser.Password = old.Password if wildcard { desc.WildcardUser = &newuser } else { desc.Users[username] = newuser } return rewriteDescriptionFile(desc.FileName, desc) } func SetUserPassword(group, username string, wildcard bool, pw Password) error { if wildcard && username != "" { return errors.New("wildcard with username") } groups.mu.Lock() defer groups.mu.Unlock() desc, err := readDescription(group, false) if err != nil { return err } if desc.Users == nil { return os.ErrNotExist } if wildcard { if desc.WildcardUser == nil { return os.ErrNotExist } desc.WildcardUser.Password = pw } else { user, ok := desc.Users[username] if !ok { return os.ErrNotExist } user.Password = pw desc.Users[username] = user } return rewriteDescriptionFile(desc.FileName, desc) }