gvguichet/admin.go

573 lines
14 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
}
can_admin := false
for _, group := range login.UserEntry.GetAttributeValues("memberof") {
if config.GroupCanAdmin != "" && group == config.GroupCanAdmin {
can_admin = true
}
}
if !can_admin {
http.Redirect(w, r, "/", http.StatusFound)
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-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-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
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", "displayname"},
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,
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-09 23:04:37 +01:00
Path []PathItem
Children []Child
2020-02-09 23:13:33 +01:00
CanAddChild bool
2020-02-09 23:04:37 +01:00
Props map[string]*PropValues
2020-02-09 23:20:44 +01:00
CanDelete bool
HasMembers bool
2020-02-09 23:04:37 +01:00
Members []EntryName
HasGroups bool
Groups []EntryName
2020-02-09 22:32:59 +01:00
2020-02-09 23:04:37 +01:00
Error string
2020-02-09 22:32:59 +01:00
Success bool
}
type EntryName struct {
2020-02-09 23:04:37 +01:00
DN string
2020-02-09 22:32:59 +01:00
DisplayName string
2020-02-09 22:06:33 +01:00
}
type Child struct {
2020-02-09 23:04:37 +01:00
DN string
Identifier string
2020-02-09 22:06:33 +01:00
DisplayName string
}
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-09 23:04:37 +01:00
Name string
Values []string
2020-02-09 22:06:33 +01:00
Editable bool
}
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 {
http.Redirect(w, r, "/admin/ldap/" + strings.Join(dn_split[1:], ","), http.StatusFound)
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 {
http.Error(w, fmt.Sprintf("%d objects found", len(sr.Entries)), http.StatusInternalServerError)
return
}
object := sr.Entries[0]
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
}
}
props[name_lower] = &PropValues{
2020-02-09 23:04:37 +01:00
Name: attr.Name,
Values: attr.Values,
2020-02-09 22:06:33 +01:00
Editable: editable,
}
}
}
}
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{}
if len(members_dn) > 0 {
mapDnToName := make(map[string]string)
searchRequest = ldap.NewSearchRequest(
config.UserBaseDN,
ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false,
fmt.Sprintf("(objectClass=organizationalPerson)"),
[]string{"dn", "displayname"},
nil)
sr, err := login.conn.Search(searchRequest)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
for _, ent := range sr.Entries {
mapDnToName[ent.DN] = ent.GetAttributeValue("displayname")
}
for _, memdn := range members_dn {
members = append(members, EntryName{
2020-02-09 23:04:37 +01:00
DN: memdn,
2020-02-09 22:32:59 +01:00
DisplayName: mapDnToName[memdn],
})
}
}
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{}
if len(groups_dn) > 0 {
mapDnToName := make(map[string]string)
searchRequest = ldap.NewSearchRequest(
config.GroupBaseDN,
ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false,
fmt.Sprintf("(objectClass=groupOfNames)"),
[]string{"dn", "displayname"},
nil)
sr, err := login.conn.Search(searchRequest)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
for _, ent := range sr.Entries {
mapDnToName[ent.DN] = ent.GetAttributeValue("displayname")
}
for _, grpdn := range groups_dn {
groups = append(groups, EntryName{
2020-02-09 23:04:37 +01:00
DN: grpdn,
2020-02-09 22:32:59 +01:00
DisplayName: mapDnToName[grpdn],
})
}
}
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"},
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 {
children = append(children, Child{
2020-02-09 23:04:37 +01:00
DN: item.DN,
Identifier: strings.Split(item.DN, ",")[0],
2020-02-09 22:06:33 +01:00
DisplayName: item.GetAttributeValue("displayname"),
})
}
// Checkup objectclass
objectClass := []string{}
if val, ok := props["objectclass"]; ok {
objectClass = val.Values
}
hasMembers, hasGroups := false, false
for _, oc := range objectClass {
if strings.EqualFold(oc, "organizationalperson") || strings.EqualFold(oc, "person") {
hasGroups = true
}
if strings.EqualFold(oc, "groupOfNames") {
hasMembers = true
}
}
2020-02-09 22:06:33 +01:00
templateAdminLDAP.Execute(w, &AdminLDAPTplData{
DN: dn,
2020-02-09 23:04:37 +01:00
Path: path,
Children: children,
2020-02-09 23:04:37 +01:00
Props: props,
2020-02-09 23:13:33 +01:00
CanAddChild: dn_last_attr == "ou",
2020-02-09 23:20:44 +01:00
CanDelete: dn != config.BaseDN && len(children) == 0,
HasMembers: len(members) > 0 || hasMembers,
2020-02-09 23:04:37 +01:00
Members: members,
HasGroups: len(groups) > 0 || hasGroups,
Groups: groups,
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
2020-02-09 23:13:33 +01:00
Path []PathItem
2020-02-09 23:04:27 +01:00
2020-02-09 23:04:37 +01:00
IdType string
IdValue string
DisplayName 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-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-09 23:13:33 +01:00
Path: path,
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-09 23:13:33 +01:00
} else {
data.IdType = "cn"
data.ObjectClass = "top"
2020-02-09 23:04:27 +01:00
}
if r.Method == "POST" {
r.ParseForm()
data.IdType = strings.Join(r.Form["idtype"], "")
data.IdValue = strings.Join(r.Form["idvalue"], "")
data.DisplayName = strings.Join(r.Form["displayname"], "")
data.StructuralObjectClass = strings.Join(r.Form["soc"], "")
data.ObjectClass = strings.Join(r.Form["oc"], "")
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)
req.Attribute("objectClass", object_class)
req.Attribute("structuralObjectClass",
[]string{data.StructuralObjectClass})
req.Attribute("displayname", []string{data.DisplayName})
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)
}