Example #1
0
//TODO refactor variable names
func GetFromLDAP(connect *ldap.Conn, LDAPBaseDN, LDAPFilter string, LDAPAttribute []string, LDAPPage uint32) *[]LDAPElement {
	searchRequest := ldap.NewSearchRequest(LDAPBaseDN, ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false, LDAPFilter, LDAPAttribute, nil)
	sr, err := connect.SearchWithPaging(searchRequest, LDAPPage)
	CheckForError(err)
	//fmt.Println(len(sr.Entries))
	ADElements := []LDAPElement{}
	for _, entry := range sr.Entries {
		NewADEntity := new(LDAPElement)
		NewADEntity.DN = entry.DN
		for _, attrib := range entry.Attributes {
			NewADEntity.attributes = append(NewADEntity.attributes, keyvalue{attrib.Name: attrib.Values})
		}
		ADElements = append(ADElements, *NewADEntity)
	}
	return &ADElements
}
Example #2
0
func GetFromAD(connect *ldap.Conn, ADBaseDN, ADFilter string, ADAttribute []string, ADPage uint32) *[]LDAPElement {
	//sizelimit in searchrequest is the limit, which throws an error when the number of results exceeds the limit.
	searchRequest := ldap.NewSearchRequest(ADBaseDN, ldap.ScopeWholeSubtree, ldap.NeverDerefAliases, 0, 0, false, ADFilter, ADAttribute, nil)
	sr, err := connect.SearchWithPaging(searchRequest, ADPage)
	CheckForError(err)
	//fmt.Println(len(sr.Entries))
	ADElements := []LDAPElement{}
	for _, entry := range sr.Entries {
		NewADEntity := new(LDAPElement)
		NewADEntity.DN = entry.DN
		for _, attrib := range entry.Attributes {
			NewADEntity.attributes = append(NewADEntity.attributes, keyvalue{attrib.Name: attrib.Values})
		}
		ADElements = append(ADElements, *NewADEntity)
	}
	return &ADElements
}
func CheckAttributes(LdapConnection *ldap.Conn, LdapEntry, ADEntry *ldap.AddRequest) {
	var ADMapAggregated []MapADandLDAP
	var LDAPMapAggregated []MapADandLDAP
	for _, adEntries := range ADEntry.Attributes {
		if adEntries.Type == "memberOf" {
			adEntries.Vals = *ConvertAttributesToLower(&adEntries.Vals)
		}
		sort.Strings(adEntries.Vals)
		ADMapped := MapADandLDAP{adEntries.Type: adEntries.Vals}
		ADMapAggregated = append(ADMapAggregated, ADMapped)
	}
	for _, ldapEntries := range LdapEntry.Attributes {
		sort.Strings(ldapEntries.Vals)
		LDAPMapped := MapADandLDAP{ldapEntries.Type: ldapEntries.Vals}
		LDAPMapAggregated = append(LDAPMapAggregated, LDAPMapped)
	}

	Info.Println("Got from AD", ADMapAggregated)
	Info.Println("Got from LD", LDAPMapAggregated)

	if reflect.DeepEqual(ADMapAggregated, LDAPMapAggregated) == true {
		Info.Println("Both entries matches, passing...")
	} else {
		Info.Println("CHANGE DETECTED")
		Info.Println("AD -> ", ADMapAggregated)
		Info.Println("LD -> ", LDAPMapAggregated)
		delete := ldap.NewDelRequest(LdapEntry.DN, []ldap.Control{})
		err := LdapConnection.Del(delete)
		if err != nil {
			Error.Println(err)
		} else {
			Info.Println(*delete, "Deleted")
		}
		err = LdapConnection.Add(ADEntry)
		if err != nil {
			Error.Println(err)
		} else {
			Info.Println(*ADEntry, "Added to ldap")
		}

	}

}
func InitialPopulateToLdap(ADElements *[]LDAPElement, connectLDAP *ldap.Conn,
	ReplaceAttributes, MapAttributes *ini.Section, ReturnData bool) []*ldap.AddRequest {
	var ReturnConvertedData []*ldap.AddRequest
	userObjectClass, err := ReplaceAttributes.GetKey("userObjectClass")
	CheckForError(err)
	groupObjectClass, err := ReplaceAttributes.GetKey("groupObjectClass")
	CheckForError(err)
	mapping := make(map[string]string) //mapping of AD values to ldap values
	for _, i := range MapAttributes.KeyStrings() {
		tmpvar, err := MapAttributes.GetKey(i)
		CheckForError(err)
		mapping[i] = tmpvar.String()
	} //keys = AD attributes, values = ldap values to which it would be mapped

	Info.Println("Creating mappings for the following attributes,", mapping)
	Info.Println("Userobjectclass of AD will be replaced with", userObjectClass)
	Info.Println("Groupobjectclass of AD will be replaced with", groupObjectClass)
	for _, i := range *ADElements {
		//fmt.Println(i.DN)
		Add := ldap.NewAddRequest(i.DN)
		for _, maps := range i.attributes {
			for key, value := range maps {

				if key == "objectClass" {
					if StringInSlice("user", value.([]string)) {
						//Add.Attribute(key, []string{"posixAccount", "top", "inetOrgPerson"})
						Add.Attribute(key, userObjectClass.Strings(","))
						continue
					}
					if StringInSlice("group", value.([]string)) {
						Add.Attribute(key, groupObjectClass.Strings(","))
						continue
					}
				}
				mappingvalue, ok := mapping[key]
				//uid := maps["uid"]
				if ok == true {
					if mappingvalue == "memberUid" {
						//members := memberTomemberUid(&value)
						Add.Attribute(mappingvalue, memberTomemberUid(&value, ADElements))
						continue
					}
					Add.Attribute(mappingvalue, value.([]string))
					continue
				}

				Add.Attribute(key, value.([]string))

			}
		}
		//		Info.Println(Add)
		if ReturnData == false {
			err := connectLDAP.Add(Add)
			Error.Println(err)
		} else {
			ReturnConvertedData = append(ReturnConvertedData, Add)
		}
		//fmt.Println(Add)

		//fmt.Println(err)

	}
	return ReturnConvertedData
}