gvguichet/admin.go

677 lines
17 KiB
Go
Raw Normal View History

2020-02-09 18:28:42 +01:00
package main
import (
2020-02-09 19:56:01 +01:00
"fmt"
2020-02-09 18:28:42 +01:00
"html/template"
"net/http"
2020-02-09 23:04:37 +01:00
"regexp"
2020-02-09 18:28:42 +01:00
"sort"
2020-02-09 23:04:37 +01:00
"strings"
2020-02-09 18:28:42 +01:00
"github.com/go-ldap/ldap/v3"
2020-02-09 22:06:33 +01:00
"github.com/gorilla/mux"
2020-02-09 18:28:42 +01:00
)
func checkAdminLogin(w http.ResponseWriter, r *http.Request) *LoginStatus {
login := checkLogin(w, r)
if login == nil {
return nil
}
2020-02-12 00:13:24 +01:00
if !login.CanAdmin {
http.Error(w, "Not authorized to perform administrative operations.", http.StatusUnauthorized)
2020-02-09 18:28:42 +01:00
return nil
}
return login
}
2020-02-09 22:06:33 +01:00
type EntryList []*ldap.Entry
func (d EntryList) Len() int {
return len(d)
}
func (d EntryList) Swap(i, j int) {
d[i], d[j] = d[j], d[i]
}
func (d EntryList) Less(i, j int) bool {
return d[i].DN < d[j].DN
}
2020-02-09 18:28:42 +01:00
type AdminUsersTplData struct {
2020-02-09 19:56:01 +01:00
Login *LoginStatus
2020-02-09 18:28:42 +01:00
UserNameAttr string
2020-02-10 09:44:18 +01:00
UserBaseDN string
2020-02-09 22:06:33 +01:00
Users EntryList
2020-02-09 18:28:42 +01:00
}
func handleAdminUsers(w http.ResponseWriter, r *http.Request) {
templateAdminUsers := template.Must(template.ParseFiles("templates/layout.html", "templates/admin_users.html"))
2020-02-09 22:06:33 +01:00
login := checkAdminLogin(w, r)
2020-02-09 18:28:42 +01:00
if login == nil {
return
}
searchRequest := ldap.NewSearchRequest(
config.UserBaseDN,
ldap.ScopeSingleLevel, ldap.NeverDerefAliases, 0, 0, false,
fmt.Sprintf("(&(objectClass=organizationalPerson))"),
[]string{config.UserNameAttr, "dn", "displayname", "givenname", "sn", "mail"},
nil)
sr, err := login.conn.Search(searchRequest)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
data := &AdminUsersTplData{
2020-02-09 19:56:01 +01:00
Login: login,
2020-02-09 18:28:42 +01:00
UserNameAttr: config.UserNameAttr,
2020-02-10 15:26:02 +01:00
UserBaseDN: config.UserBaseDN,
2020-02-09 22:06:33 +01:00
Users: EntryList(sr.Entries),
2020-02-09 18:28:42 +01:00
}
2020-02-09 22:06:33 +01:00
sort.Sort(data.Users)
2020-02-09 18:28:42 +01:00
templateAdminUsers.Execute(w, data)
}
2020-02-09 22:06:33 +01:00
type AdminGroupsTplData struct {
2020-02-09 23:04:37 +01:00
Login *LoginStatus
2020-02-09 22:06:33 +01:00
GroupNameAttr string
2020-02-10 09:44:18 +01:00
GroupBaseDN string
2020-02-09 22:06:33 +01:00
Groups EntryList
2020-02-09 18:28:42 +01:00
}
2020-02-09 22:06:33 +01:00
func handleAdminGroups(w http.ResponseWriter, r *http.Request) {
templateAdminGroups := template.Must(template.ParseFiles("templates/layout.html", "templates/admin_groups.html"))
login := checkAdminLogin(w, r)
if login == nil {
return
}
searchRequest := ldap.NewSearchRequest(
config.GroupBaseDN,
ldap.ScopeSingleLevel, ldap.NeverDerefAliases, 0, 0, false,
fmt.Sprintf("(&(objectClass=groupOfNames))"),
[]string{config.GroupNameAttr, "dn", "description"},
2020-02-09 22:06:33 +01:00
nil)
sr, err := login.conn.Search(searchRequest)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
data := &AdminGroupsTplData{
2020-02-09 23:04:37 +01:00
Login: login,
2020-02-09 22:06:33 +01:00
GroupNameAttr: config.GroupNameAttr,
2020-02-10 15:26:02 +01:00
GroupBaseDN: config.GroupBaseDN,
2020-02-09 22:06:33 +01:00
Groups: EntryList(sr.Entries),
}
sort.Sort(data.Groups)
templateAdminGroups.Execute(w, data)
2020-02-09 18:28:42 +01:00
}
2020-02-09 22:06:33 +01:00
type AdminLDAPTplData struct {
DN string
2020-02-10 15:26:02 +01:00
Path []PathItem
Children []Child
2020-02-09 23:13:33 +01:00
CanAddChild bool
2020-02-10 15:26:02 +01:00
Props map[string]*PropValues
CanDelete bool
2021-08-16 12:53:35 +02:00
HasMembers bool
Members []EntryName
PossibleNewMembers []EntryName
HasGroups bool
Groups []EntryName
PossibleNewGroups []EntryName
2020-02-09 22:32:59 +01:00
ListMemGro map[string]string
2020-02-09 23:04:37 +01:00
Error string
2020-02-09 22:32:59 +01:00
Success bool
}
type EntryName struct {
DN string
Name string
2020-02-09 22:06:33 +01:00
}
type Child struct {
DN string
Identifier string
Name string
2020-02-09 22:06:33 +01:00
}
type PathItem struct {
2020-02-09 23:04:37 +01:00
DN string
2020-02-09 22:06:33 +01:00
Identifier string
2020-02-09 23:04:37 +01:00
Active bool
2020-02-09 22:06:33 +01:00
}
type PropValues struct {
2020-02-10 15:26:02 +01:00
Name string
Values []string
Editable bool
2020-02-10 09:54:33 +01:00
Deletable bool
2020-02-09 22:06:33 +01:00
}
func handleAdminLDAP(w http.ResponseWriter, r *http.Request) {
templateAdminLDAP := template.Must(template.ParseFiles("templates/layout.html", "templates/admin_ldap.html"))
login := checkAdminLogin(w, r)
if login == nil {
return
}
dn := mux.Vars(r)["dn"]
2020-02-09 22:32:59 +01:00
dError := ""
dSuccess := false
2020-02-09 22:06:33 +01:00
2020-02-09 23:20:44 +01:00
// Build path
path := []PathItem{
PathItem{
DN: config.BaseDN,
Identifier: config.BaseDN,
Active: dn == config.BaseDN,
},
}
len_base_dn := len(strings.Split(config.BaseDN, ","))
dn_split := strings.Split(dn, ",")
dn_last_attr := strings.Split(dn_split[0], "=")[0]
for i := len_base_dn + 1; i <= len(dn_split); i++ {
path = append(path, PathItem{
DN: strings.Join(dn_split[len(dn_split)-i:len(dn_split)], ","),
Identifier: dn_split[len(dn_split)-i],
Active: i == len(dn_split),
})
}
// Handle modification operation
2020-02-09 22:06:33 +01:00
if r.Method == "POST" {
r.ParseForm()
action := strings.Join(r.Form["action"], "")
if action == "modify" {
attr := strings.Join(r.Form["attr"], "")
values := strings.Split(strings.Join(r.Form["values"], ""), "\n")
values_filtered := []string{}
for _, v := range values {
v2 := strings.TrimSpace(v)
if v2 != "" {
values_filtered = append(values_filtered, v2)
}
}
if len(values_filtered) == 0 {
2020-02-09 22:32:59 +01:00
dError = "Refusing to delete attribute."
2020-02-09 22:06:33 +01:00
} else {
modify_request := ldap.NewModifyRequest(dn, nil)
modify_request.Replace(attr, values_filtered)
err := login.conn.Modify(modify_request)
if err != nil {
2020-02-09 22:32:59 +01:00
dError = err.Error()
2020-02-09 22:06:33 +01:00
} else {
2020-02-09 22:32:59 +01:00
dSuccess = true
2020-02-09 22:06:33 +01:00
}
}
} else if action == "add" {
attr := strings.Join(r.Form["attr"], "")
values := strings.Split(strings.Join(r.Form["values"], ""), "\n")
values_filtered := []string{}
for _, v := range values {
v2 := strings.TrimSpace(v)
if v2 != "" {
values_filtered = append(values_filtered, v2)
}
}
modify_request := ldap.NewModifyRequest(dn, nil)
modify_request.Add(attr, values_filtered)
err := login.conn.Modify(modify_request)
if err != nil {
2020-02-09 22:32:59 +01:00
dError = err.Error()
} else {
dSuccess = true
2020-02-09 22:06:33 +01:00
}
} else if action == "delete" {
attr := strings.Join(r.Form["attr"], "")
modify_request := ldap.NewModifyRequest(dn, nil)
modify_request.Replace(attr, []string{})
err := login.conn.Modify(modify_request)
if err != nil {
2020-02-09 22:32:59 +01:00
dError = err.Error()
} else {
dSuccess = true
}
} else if action == "delete-from-group" {
group := strings.Join(r.Form["group"], "")
modify_request := ldap.NewModifyRequest(group, nil)
modify_request.Delete("member", []string{dn})
err := login.conn.Modify(modify_request)
if err != nil {
dError = err.Error()
} else {
dSuccess = true
}
} else if action == "add-to-group" {
group := strings.Join(r.Form["group"], "")
modify_request := ldap.NewModifyRequest(group, nil)
modify_request.Add("member", []string{dn})
err := login.conn.Modify(modify_request)
if err != nil {
dError = err.Error()
} else {
dSuccess = true
}
} else if action == "delete-member" {
member := strings.Join(r.Form["member"], "")
modify_request := ldap.NewModifyRequest(dn, nil)
modify_request.Delete("member", []string{member})
err := login.conn.Modify(modify_request)
if err != nil {
dError = err.Error()
} else {
dSuccess = true
2020-02-09 22:06:33 +01:00
}
2020-02-09 23:20:44 +01:00
} else if action == "delete-object" {
del_request := ldap.NewDelRequest(dn, nil)
err := login.conn.Del(del_request)
if err != nil {
dError = err.Error()
} else {
2020-02-10 15:26:02 +01:00
http.Redirect(w, r, "/admin/ldap/"+strings.Join(dn_split[1:], ","), http.StatusFound)
2020-02-09 23:20:44 +01:00
return
}
2020-02-09 22:06:33 +01:00
}
}
// Get object and parse it
searchRequest := ldap.NewSearchRequest(
dn,
ldap.ScopeBaseObject, ldap.NeverDerefAliases, 0, 0, false,
fmt.Sprintf("(objectclass=*)"),
[]string{},
nil)
sr, err := login.conn.Search(searchRequest)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if len(sr.Entries) != 1 {
2020-02-10 15:26:02 +01:00
http.Error(w, fmt.Sprintf("Object not found: %s", dn), http.StatusNotFound)
2020-02-09 22:06:33 +01:00
return
}
object := sr.Entries[0]
2021-08-16 12:53:35 +02:00
// Read object properties and prepare appropriate form fields
2020-02-09 22:06:33 +01:00
props := make(map[string]*PropValues)
for _, attr := range object.Attributes {
name_lower := strings.ToLower(attr.Name)
if name_lower != dn_last_attr {
if existing, ok := props[name_lower]; ok {
2020-02-09 22:06:33 +01:00
existing.Values = append(existing.Values, attr.Values...)
} else {
editable := true
for _, restricted := range []string{
"creatorsname", "modifiersname", "createtimestamp",
"modifytimestamp", "entryuuid",
} {
if strings.EqualFold(attr.Name, restricted) {
editable = false
break
}
}
2020-02-10 09:54:33 +01:00
deletable := true
for _, restricted := range []string{"objectclass", "structuralobjectclass"} {
2020-02-10 09:54:33 +01:00
if strings.EqualFold(attr.Name, restricted) {
deletable = false
break
}
}
props[name_lower] = &PropValues{
2020-02-10 15:26:02 +01:00
Name: attr.Name,
Values: attr.Values,
Editable: editable,
2020-02-10 09:54:33 +01:00
Deletable: deletable,
2020-02-09 22:06:33 +01:00
}
}
}
}
2021-08-16 12:53:35 +02:00
// Check objectclass to determine object type
objectClass := []string{}
if val, ok := props["objectclass"]; ok {
objectClass = val.Values
}
hasMembers, hasGroups, isOrganization := false, false, false
for _, oc := range objectClass {
if strings.EqualFold(oc, "organizationalperson") || strings.EqualFold(oc, "person") {
hasGroups = true
}
if strings.EqualFold(oc, "groupOfNames") {
hasMembers = true
}
if strings.EqualFold(oc, "organization") {
isOrganization = true
}
}
// Parse member list and prepare form section
2020-02-09 22:32:59 +01:00
members_dn := []string{}
2020-02-09 22:06:33 +01:00
if mp, ok := props["member"]; ok {
2020-02-09 22:32:59 +01:00
members_dn = mp.Values
2020-02-09 22:06:33 +01:00
delete(props, "member")
}
2020-02-09 22:32:59 +01:00
members := []EntryName{}
2021-08-16 12:53:35 +02:00
possibleNewMembers := []EntryName{}
if len(members_dn) > 0 || hasMembers {
// Lookup all existing users in the server
// to know the DN -> display name correspondance
searchRequest = ldap.NewSearchRequest(
config.UserBaseDN,
ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false,
fmt.Sprintf("(objectClass=organizationalPerson)"),
[]string{"dn", "displayname", "description"},
nil)
sr, err = login.conn.Search(searchRequest)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
userMap := make(map[string]string)
for _, ent := range sr.Entries {
userMap[ent.DN] = ent.GetAttributeValue("displayname")
if userMap[ent.DN] == "" {
userMap[ent.DN] = ent.GetAttributeValue("description")
}
}
// Select members with their name and remove them from map
for _, memdn := range members_dn {
members = append(members, EntryName{
DN: memdn,
Name: userMap[memdn],
})
delete(userMap, memdn)
}
// Create list of members that can be added
for dn, name := range userMap {
entry := EntryName{
DN: dn,
Name: name,
}
if entry.Name == "" {
entry.Name = entry.DN
}
possibleNewMembers = append(possibleNewMembers, entry)
2020-02-09 22:32:59 +01:00
}
}
2020-02-09 22:32:59 +01:00
2021-08-16 12:53:35 +02:00
// Parse group list and prepare form section
2020-02-09 22:32:59 +01:00
groups_dn := []string{}
2020-02-09 22:06:33 +01:00
if gp, ok := props["memberof"]; ok {
2020-02-09 22:32:59 +01:00
groups_dn = gp.Values
2020-02-09 22:06:33 +01:00
delete(props, "memberof")
}
2020-02-09 22:32:59 +01:00
groups := []EntryName{}
2021-08-16 12:53:35 +02:00
possibleNewGroups := []EntryName{}
if len(groups_dn) > 0 || hasGroups {
// Lookup all existing groups in the server
// to know the DN -> display name correspondance
searchRequest = ldap.NewSearchRequest(
config.GroupBaseDN,
ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false,
fmt.Sprintf("(objectClass=groupOfNames)"),
[]string{"dn", "description"},
nil)
sr, err = login.conn.Search(searchRequest)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
groupMap := make(map[string]string)
for _, ent := range sr.Entries {
groupMap[ent.DN] = ent.GetAttributeValue("displayname")
if groupMap[ent.DN] == "" {
groupMap[ent.DN] = ent.GetAttributeValue("description")
}
}
// Calculate list of current groups
for _, grpdn := range groups_dn {
groups = append(groups, EntryName{
DN: grpdn,
Name: groupMap[grpdn],
})
delete(groupMap, grpdn)
}
// Calculate list of possible new groups
for dn, name := range groupMap {
entry := EntryName{
DN: dn,
Name: name,
}
if entry.Name == "" {
entry.Name = entry.DN
}
possibleNewGroups = append(possibleNewGroups, entry)
}
2020-02-09 22:32:59 +01:00
}
2020-02-09 22:06:33 +01:00
// Get children
searchRequest = ldap.NewSearchRequest(
dn,
ldap.ScopeSingleLevel, ldap.NeverDerefAliases, 0, 0, false,
fmt.Sprintf("(objectclass=*)"),
[]string{"dn", "displayname", "description"},
2020-02-09 22:06:33 +01:00
nil)
sr, err = login.conn.Search(searchRequest)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
sort.Sort(EntryList(sr.Entries))
children := []Child{}
for _, item := range sr.Entries {
name := item.GetAttributeValue("displayname")
if name == "" {
name = item.GetAttributeValue("description")
}
2020-02-09 22:06:33 +01:00
children = append(children, Child{
DN: item.DN,
Identifier: strings.Split(item.DN, ",")[0],
Name: name,
2020-02-09 22:06:33 +01:00
})
}
2021-08-16 12:53:35 +02:00
// Run template, finally!
2020-02-09 22:06:33 +01:00
templateAdminLDAP.Execute(w, &AdminLDAPTplData{
DN: dn,
2020-02-10 15:26:02 +01:00
Path: path,
Children: children,
Props: props,
2020-02-10 09:44:18 +01:00
CanAddChild: dn_last_attr == "ou" || isOrganization,
2020-02-10 15:26:02 +01:00
CanDelete: dn != config.BaseDN && len(children) == 0,
2021-08-16 12:53:35 +02:00
HasMembers: len(members) > 0 || hasMembers,
Members: members,
PossibleNewMembers: possibleNewMembers,
HasGroups: len(groups) > 0 || hasGroups,
Groups: groups,
PossibleNewGroups: possibleNewGroups,
2020-02-09 23:04:37 +01:00
Error: dError,
2020-02-09 22:32:59 +01:00
Success: dSuccess,
2020-02-09 22:06:33 +01:00
})
2020-02-09 18:28:42 +01:00
}
2020-02-09 23:04:27 +01:00
type CreateData struct {
SuperDN string
Path []PathItem
Template string
2020-02-09 23:04:27 +01:00
2020-02-09 23:04:37 +01:00
IdType string
IdValue string
DisplayName string
Description string
2020-02-09 23:04:27 +01:00
StructuralObjectClass string
2020-02-09 23:04:37 +01:00
ObjectClass string
2020-02-09 23:04:27 +01:00
Error string
}
func handleAdminCreate(w http.ResponseWriter, r *http.Request) {
templateAdminCreate := template.Must(template.ParseFiles("templates/layout.html", "templates/admin_create.html"))
login := checkAdminLogin(w, r)
if login == nil {
return
}
template := mux.Vars(r)["template"]
super_dn := mux.Vars(r)["super_dn"]
2020-02-10 15:26:02 +01:00
// Check that base DN exists
searchRequest := ldap.NewSearchRequest(
super_dn,
ldap.ScopeBaseObject, ldap.NeverDerefAliases, 0, 0, false,
fmt.Sprintf("(objectclass=*)"),
[]string{},
nil)
sr, err := login.conn.Search(searchRequest)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if len(sr.Entries) != 1 {
http.Error(w, fmt.Sprintf("Parent object %s does not exist", super_dn), http.StatusNotFound)
return
}
2020-02-09 23:13:33 +01:00
// Build path
path := []PathItem{
PathItem{
DN: config.BaseDN,
Identifier: config.BaseDN,
},
}
len_base_dn := len(strings.Split(config.BaseDN, ","))
dn_split := strings.Split(super_dn, ",")
for i := len_base_dn + 1; i <= len(dn_split); i++ {
path = append(path, PathItem{
DN: strings.Join(dn_split[len(dn_split)-i:len(dn_split)], ","),
Identifier: dn_split[len(dn_split)-i],
})
}
// Handle data
2020-02-09 23:04:27 +01:00
data := &CreateData{
SuperDN: super_dn,
2020-02-10 15:26:02 +01:00
Path: path,
2020-02-09 23:04:27 +01:00
}
data.Template = template
2020-02-09 23:04:27 +01:00
if template == "user" {
data.IdType = config.UserNameAttr
data.StructuralObjectClass = "inetOrgPerson"
data.ObjectClass = "inetOrgPerson\norganizationalPerson\nperson\ntop"
} else if template == "group" {
data.IdType = config.UserNameAttr
data.StructuralObjectClass = "groupOfNames"
data.ObjectClass = "groupOfNames\ntop"
2020-02-10 15:26:02 +01:00
} else if template == "ou" {
data.IdType = "ou"
data.StructuralObjectClass = "organizationalUnit"
data.ObjectClass = "organizationalUnit\ntop"
2020-02-09 23:13:33 +01:00
} else {
data.IdType = "cn"
data.ObjectClass = "top"
data.Template = ""
2020-02-09 23:04:27 +01:00
}
if r.Method == "POST" {
r.ParseForm()
if data.Template == "" {
2020-02-10 15:26:02 +01:00
data.IdType = strings.TrimSpace(strings.Join(r.Form["idtype"], ""))
data.StructuralObjectClass = strings.TrimSpace(strings.Join(r.Form["soc"], ""))
2020-02-10 09:48:55 +01:00
data.ObjectClass = strings.Join(r.Form["oc"], "")
}
2020-02-10 15:26:02 +01:00
data.IdValue = strings.TrimSpace(strings.Join(r.Form["idvalue"], ""))
data.DisplayName = strings.TrimSpace(strings.Join(r.Form["displayname"], ""))
data.Description = strings.TrimSpace(strings.Join(r.Form["description"], ""))
2020-02-09 23:04:27 +01:00
object_class := []string{}
for _, oc := range strings.Split(data.ObjectClass, "\n") {
x := strings.TrimSpace(oc)
if x != "" {
object_class = append(object_class, x)
}
}
if len(object_class) == 0 {
data.Error = "No object class specified"
} else if match, err := regexp.MatchString("^[a-z]+$", data.IdType); err != nil || !match {
data.Error = "Invalid identifier type"
} else if len(data.IdValue) == 0 {
data.Error = "No identifier specified"
} else if match, err := regexp.MatchString("^[\\d\\w_-]+$", data.IdValue); err != nil || !match {
data.Error = "Invalid identifier"
} else {
dn := data.IdType + "=" + data.IdValue + "," + super_dn
req := ldap.NewAddRequest(dn, nil)
2020-02-14 21:58:34 +01:00
req.Attribute("objectclass", object_class)
if data.StructuralObjectClass != "" {
2020-02-14 21:58:34 +01:00
req.Attribute("structuralobjectclass", []string{data.StructuralObjectClass})
}
2020-02-10 15:26:02 +01:00
if data.DisplayName != "" {
req.Attribute("displayname", []string{data.DisplayName})
}
if data.Description != "" {
req.Attribute("description", []string{data.Description})
}
2020-02-10 15:26:02 +01:00
2020-02-09 23:04:27 +01:00
err := login.conn.Add(req)
if err != nil {
data.Error = err.Error()
} else {
2020-02-09 23:04:37 +01:00
http.Redirect(w, r, "/admin/ldap/"+dn, http.StatusFound)
2020-02-09 23:04:27 +01:00
}
2020-02-09 23:04:37 +01:00
2020-02-09 23:04:27 +01:00
}
}
templateAdminCreate.Execute(w, data)
}