def __init__(self, *args, **kwargs): self.dispatcher = kwargs.get('dispatcher') self.datastore = kwargs.get('datastore') sys.path.extend(['/usr/local/lib/dsd/modules/']) from dsdns import DSDNS self.dsdns = DSDNS( dispatcher=self.dispatcher, datastore=self.datastore, )
class ActiveDirectory(object): class ActiveDirectoryHandle(object): def __init__(self, host, binddn, bindpw): self.__host = host self.__binddn = binddn self.__bindpw = bindpw self.__dchandle = self.get_dc_handle() self.__gchandle = self.get_gc_handle() def get_connection_handle(self, host, port, binddn, bindpw): server = ldap3.Server(host, port=port, get_info=ldap3.ALL) conn = ldap3.Connection(server, user=binddn, password=bindpw, authentication=ldap3.AUTH_SIMPLE, auto_bind=True) return conn @property def dchandle(self): return self.__dchandle def get_dc_handle(self): return self.get_connection_handle( self.__host, 389, self.__binddn, self.__bindpw ) @property def gchandle(self): return self.__gchandle def get_gc_handle(self): return self.get_connection_handle( self.__host, 3268, self.__binddn, self.__bindpw ) def __init__(self, *args, **kwargs): self.dispatcher = kwargs.get('dispatcher') self.datastore = kwargs.get('datastore') sys.path.extend(['/usr/local/lib/dsd/modules/']) from dsdns import DSDNS self.dsdns = DSDNS( dispatcher=self.dispatcher, datastore=self.datastore, ) def get_directory_type(self): return "activedirectory" def get_connection_handle(self, host, binddn, bindpw): return self.ActiveDirectoryHandle(host, binddn, bindpw) def get_ldap_servers(self, domain, site=None): dcs = [] if not domain: return dcs host = "_ldap._tcp.%s" % domain if site: host = "_ldap._tcp.%s._sites.%s" % (site, domain) logger.debug("get_ldap_servers: host = %s", host) dcs = self.dsdns.get_SRV_records(host) for dc in dcs: logger.debug("get_ldap_servers: found %s", dc) return dcs def get_domain_controllers(self, domain, site=None): dcs = [] if not domain: return dcs host = "_ldap._tcp.dc._msdcs.%s" % domain if site: host = "_ldap._tcp.%s._sites.dc._msdcs.%s" % (site, domain) logger.debug("get_domain_controllers: host = %s", host) dcs = self.dsdns.get_SRV_records(host) for dc in dcs: logger.debug("get_domain_controllers: found %s", dc) return dcs def get_primary_domain_controllers(self, domain): pdcs = [] if not domain: return pdcs host = "_ldap._tcp.pdc._msdcs.%s" logger.debug("get_primary_domain_controllers: host = %s", host) pdcs = self.dsdns.get_SRV_records(host) for pdc in pdcs: logger.debug("get_primary_domain_controllers: found %s", pdc) return pdcs def get_global_catalog_servers(self, domain, site=None): gcs = [] if not domain: return gcs host = "_gc._tcp.%s" % domain if site: host = "_gc._tcp.%s._sites.%s" % (site, domain) logger.debug("get_global_catalog_servers: host = %s", host) gcs = self.dsdns.get_SRV_records(host) for gc in gcs: logger.debug("get_global_catalog_servers: found %s", gc) return gcs def get_forest_global_catalog_servers(self, forest, site=None): fgcs = [] if not forest: return fgcs host = "_ldap._tcp.gc._msdcs.%s" % forest if site: host = "_ldap._tcp.%s._sites.gc._msdcs.%s" % (site, forest) logger.debug("get_forest_global_catalog_servers: host = %s", host) fgcs = self.dsdns.get_SRV_records(host) for fgc in fgcs: logger.debug("get_forest_global_catalog_servers: found %s", fgc) return fgcs def get_kerberos_servers(self, domain, site=None): kdcs = [] if not domain: return kdcs host = "_kerberos._tcp.%s" % domain if site: host = "_kerberos._tcp.%s._sites.%s" % (site, domain) logger.debug("get_kerberos_servers: host = %s", host) kdcs = self.dsdns.get_SRV_records(host) for kdc in kdcs: logger.debug("get_kerberos_servers: found %s", kdc) return kdcs def get_kerberos_domain_controllers(self, domain, site=None): kdcs = [] if not domain: return kdcs host = "_kerberos._tcp.dc._msdcs.%s" % domain if site: host = "_kerberos._tcp.%s._sites.dc._msdcs.%s" % (site, domain) logger.debug("get_kerberos_domain_controllers: host = %s", host) kdcs = self.dsdns.get_SRV_records(host) for kdc in kdcs: logger.debug("get_kerberos_domain_controllers: found %s", kdc) return kdcs def get_kpasswd_servers(self, domain): kpws = [] if not domain: return kpws host = "_kpasswd._tcp.%s" % domain logger.debug("get_kpasswd_servers: host = %s", host) kpws = self.dsdns.get_SRV_records(host) for kpw in kpws: logger.debug("get_kpasswd_servers: found %s", kpwd) return kpws def get_rootDSE(self, handle): dchandle = handle.dchandle dchandle.search('', '(objectclass=*)', search_scope=ldap3.BASE, attributes=ldap3.ALL_ATTRIBUTES, ) if not dchandle.result: return None if not dchandle.response: return None results = dchandle.response[0] if not results: return None attributes = results.get('attributes', None) if not attributes: return None return attributes def get_rootDN(self, handle): rootDSE = self.get_rootDSE(handle) if not rootDSE: return None rootDN = rootDSE.get('rootDomainNamingContext', None) if not rootDN: return None rootDN = rootDN[0].strip() logger.debug("get_rootDN: rootDN = %s", rootDN) return rootDN def get_baseDN(self, handle): rootDSE = self.get_rootDSE(handle) if not rootDSE: return None baseDN = rootDSE.get('defaultNamingContext', None) if not baseDN: return None baseDN = baseDN[0].strip() logger.debug("get_baseDN: baseDN = %s", baseDN) return baseDN def get_configurationDN(self, handle): rootDSE = self.get_rootDSE(handle) if not rootDSE: return None configurationDN = rootDSE.get('configurationNamingContext', None) if not configurationDN: return None configurationDN = configurationDN[0].strip() logger.debug("get_configurationDN: configurationDN = %s", configurationDN) return configurationDN def get_forest_functionality(self, handle): rootDSE = self.get_rootDSE(handle) if not rootDSE: return None forest_functionality = rootDSE.get('forestFunctionality', None) if not forest_functionality: return None forest_functionality = int(forest_functionality[0].strip()) logger.debug("get_forest_functionality: forest_functionality = %d", forest_functionality) return forest_functionality def get_domain_functionality(self, handle): rootDSE = self.get_rootDSE(handle) if not rootDSE: return None domain_functionality = rootDSE.get('domainFunctionality', None) if not domain_functionality: return None domain_functionality = int(domain_functionality[0].strip()) logger.debug("get_domain_functionality: domain_functionality = %d", domain_functionality) return domain_functionality def get_domain_controller_functionality(self, handle): rootDSE = self.get_rootDSE(handle) if not rootDSE: return None domain_controller_functionality = rootDSE.get('domainControllerFunctionality', None) if not domain_controller_functionality: return None domain_controller_functionality = int(domain_controller_functionality[0].strip()) logger.debug("get_domain_controller_functionality: domain_controller_functionality = %d", domain_controller_functionality) return domain_controller_functionality def get_domain_netbiosname(self, handle): dchandle = handle.dchandle baseDN = self.get_baseDN(handle) configurationDN = self.get_configurationDN(handle) filter = "(&(objectcategory=crossref)(nCName=%s))" % baseDN logger.debug("get_domain_netbiosname: filter = %s", filter) dchandle.search(configurationDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not dchandle.result: return None if not dchandle.response: return None attributes = dchandle.response[0].get('attributes', None) if not attributes: return None netbiosname = attributes.get('nETBIOSName', None) if not netbiosname: return None netbiosname = netbiosname.strip() logger.debug("get_domain_netbiosname: netbiosname = %s", netbiosname) return netbiosname def get_partitions(self, handle, **kwargs): dchandle = handle.dchandle configurationDN = self.get_configurationDN(handle) baseDN = "CN=Partitions,%s" % configurationDN filter = None keys = ['netbiosname', 'name', 'cn', 'dn', 'distinguishedname', 'ncname'] for k in keys: if kwargs.has_key(k) and kwargs[k]: filter = "(%s=%s)" % (k, kwargs[k]) break if filter is None: filter = "(cn=*)" logger.debug("get_partitions: filter = %s", filter) dchandle.search(baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES, ) if not dchandle.result: return None partitions = [] for result in dchandle.response: attributes = result.get('attributes', None) if not attributes: continue partitions.append(attributes) return partitions def get_root_domain(self, handle): rootDN = self.get_rootDN(handle) partitions = self.get_partitions(handle, ncname=rootDN) if not partitions: return None domain = None try: domain = partitions[0]['dnsRoot'][0] except: return None domain = domain.strip() logger.debug("get_root_domain: domain = %s", domain) return domain def get_domain(self, handle, **kwargs): partitions = self.get_partitions(handle, **kwargs) if not partitions: return None domain = None try: domain = partitions[0]['dnsRoot'][0] except: return None domain = domain.strip() logger.debug("get_domain: domain = %s", domain) return domain def get_domains(self, handle, **kwargs): dchandle = handle.dchandle gchandle = handle.gchandle gchandle.search('', '(objectclass=domain)', search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not gchandle.result: return None domains = [] for result in gchandle.response: attributes = result.get('attributes', None) if not attributes: continue domains.append(attributes) configurationDN = self.get_configurationDN(handle) results = [] haskey = False keys = ['netbiosname', 'name', 'cn', 'dn', 'distinguishedname', 'ncname'] for domain in domains: dn = domain.get('distinguishedName', None) if not dn: continue dn = dn.strip() filter = None if len(kwargs) > 0: haskey = True for k in keys: if kwargs.has_key(k) and kwargs[k]: filter = "(&(objectcategory=crossref)(%s=%s))" % (k, kwargs[k]) break if filter is None: filter = "(&(objectcategory=crossref)(nCName=%s))" % dn logger.debug("get_domains: filter = %s", filter) dchandle.search( configurationDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not dchandle.result: continue for result in dchandle.response: attributes = result.get('attributes', None) if not attributes: continue results.append(attributes) if haskey: break return results def get_subnets(self, handle, **kwargs): dchandle = handle.dchandle configurationDN = self.get_configurationDN(handle) baseDN = "CN=Subnets,CN=Sites,%s" % configurationDN filter = '(objectClass=subnet)' keys = ['distinguishedname', 'cn', 'name', 'siteobjectbl'] for k in keys: if kwargs.has_key(k) and kwargs[k]: filter = "(&%s(%s=%s))" % (filter, k, kwargs[k]) subnets = [] logger.debug("get_subnets: filter = %s", filter) dchandle.search( configurationDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not dchandle.result: return subnets for result in dchandle.response: attributes = result.get('attributes', None) if not attributes: return subnets subnets.append(attributes) return subnets def get_sites(self, handle, **kwargs): dchandle = handle.dchandle configurationDN = self.get_configurationDN(handle) baseDN = "CN=Sites,%s" % configurationDN filter = '(objectClass=site)' keys = ['distinguishedname', 'cn', 'name', 'siteobjectbl'] for k in keys: if kwargs.has_key(k) and kwargs[k]: filter = "(&%s(%s=%s))" % (filter, k, kwargs[k]) sites = [] logger.debug("get_sites: filter = %s", filter) dchandle.search( configurationDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not dchandle.result: return sites for result in dchandle.response: attributes = result.get('attributes', None) if not attributes: return sites sites.append(attributes) return sites def get_machine_account(self, handle, hostname): dchandle = handle.dchandle hostname = hostname.split('.')[0] baseDN = self.get_baseDN(handle) filter = '(&(objectClass=computer)(sAMAccountName=%s$))' % hostname logger.debug("get_machine_account: filter = %s", filter) dchandle.search( baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not dchandle.result: return None if not dchandle.response: return None attributes = dchandle.response[0].get('attributes', None) if not attributes: return None return attributes def get_users(self, handle, **kwargs): dchandle = handle.dchandle baseDN = self.get_baseDN(handle) filter = '(&(|(objectclass=user)(objectclass=person))(sAMAccountName=*))' logger.debug("get_users: filter = %s", filter) dchandle.search( baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) users = [] if not dchandle.result: return users filter_func = lambda x: 'sAMAccountType' in x and \ (long(x['sAMAccountType']) != SAM_USER_OBJECT) if 'filter' in kwargs and kwargs['filter']: filter_func = kwargs['filter'] for result in dchandle.response: attributes = result.get('attributes', None) if not attributes: continue if filter_func: if filter_func(attributes): continue users.append(attributes) return users def get_groups(self, handle, **kwargs): dchandle = handle.dchandle baseDN = self.get_baseDN(handle) filter = '(&(objectclass=group)(sAMAccountName=*))' logger.debug("get_groups: filter = %s", filter) dchandle.search( baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) groups = [] if not dchandle.result: return groups filter_func = lambda x: 'groupType' in x and \ (long(x['groupType']) & GROUP_TYPE_BUILTIN_LOCAL_GROUP) if 'filter' in kwargs and kwargs['filter']: filter_func = kwargs['filter'] for result in dchandle.response: attributes = result.get('attributes', None) if not attributes: continue if filter_func: if filter_func(attributes): continue groups.append(attributes) return groups def get_user(self, handle, user): dchandle = handle.dchandle baseDN = self.get_baseDN(handle) filter = '(&(|(objectclass=user)(objectclass=person))' \ '(sAMAccountName=%s))' % user logger.debug("get_user: filter = %s", filter) dchandle.search( baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not dchandle.result: return [] if not dchandle.response: return [] attributes = dchandle.response[0].get('attributes', None) if not attributes: return [] return attributes def get_group(self, handle, group): dchandle = handle.dchandle baseDN = self.get_baseDN(handle) filter = '(&(objectclass=group)(sAMAccountName=%s))' % group logger.debug("get_group: filter = %s", filter) dchandle.search( baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not dchandle.result: return [] if not dchandle.response: return [] attributes = dchandle.response[0].get('attributes', None) if not attributes: return [] return attributes def get_userDN(self, handle, user): user = self.get_user(handle, user) if not user: return None userDN = user['distinguishedName'].strip() logger.debug("get_userDN: userDN = %s", userDN) return userDN def get_groupDN(self, handle, group): group = self.get_group(handle, group) if not group: return None groupDN = group['distinguishedName'].strip() logger.debug("get_groupDN: groupDN = %s", groupDN) return groupDN
class Kerberos(object): def __init__(self, *args, **kwargs): self.dispatcher = kwargs.get('dispatcher') self.datastore = kwargs.get('datastore') sys.path.extend(['/usr/local/lib/dsd/modules/']) from dsdns import DSDNS self.dsdns = DSDNS( dispatcher=self.dispatcher, datastore=self.datastore, ) def get_directory_type(self): return "kerberos" def get_kerberos_servers(self, domain, proto='tcp'): kerberos_servers = [] if not domain: return kerberos_servers if proto is None: proto = ['tcp', 'udp'] if 'tcp' in proto: tcp_host = "_kerberos._tcp.%s" % domain logger.debug("get_kerberos_servers: tcp_host = %s", tcp_host) tcp_kerberos_servers = self.dsdns.get_SRV_records(tcp_host) if tcp_kerberos_servers: kerberos_servers += tcp_kerberos_servers if 'udp' in proto: udp_host = "_kerberos._tcp.%s" % domain logger.debug("get_kerberos_servers: udp_host = %s", udp_host) udp_kerberos_servers = self.dsdns.get_SRV_records(tcp_host) if udp_kerberos_servers: kerberos_servers += udp_kerberos_servers for ks in kerberos_servers: logger.debug("get_kerberos_servers: found %s", ks) return kerberos_servers def get_kpasswd_servers(self, domain, proto='tcp'): kpasswd_servers = [] if not domain: return kpasswd_servers if proto is None: proto = ['tcp', 'udp'] if 'tcp' in proto: tcp_host = "_kpasswd._tcp.%s" % domain logger.debug("get_kpasswd_servers: tcp_host = %s", tcp_host) tcp_kpasswd_servers = self.dsdns.get_SRV_records(tcp_host) if tcp_kpasswd_servers: kpasswd_servers += tcp_kpasswd_servers if 'udp' in proto: udp_host = "_kpasswd._udp.%s" % domain logger.debug("get_kpasswd_servers: udp_host = %s", udp_host) udp_kpasswd_servers = self.dsdns.get_SRV_records(udp_host) if udp_kpasswd_servers: kpasswd_servers += udp_kpasswd_servers for kpws in kpasswd_servers: logger.debug("get_kpasswd_servers: found %s", kpws) return kpasswd_servers def get_kerberos_master_servers(self, domain, proto='tcp'): kerberos_master_servers = [] if not domain: return kerberos_master_servers if proto is None: proto = ['tcp', 'udp'] if 'tcp' in proto: tcp_host = "_kerberos-master._tcp.%s" % domain logger.debug("get_kerberos_master_servers: tcp_host = %s", tcp_host) tcp_kerberos_master_servers = self.dsdns.get_SRV_records(tcp_host) if tcp_kerberos_master_servers: kerberos_master_servers += tcp_kerberos_master_servers if 'udp' in proto: udp_host = "_kerberos-master._tcp.%s" % domain logger.debug("get_kerberos_master_servers: udp_host = %s", udp_host) udp_kerberos_master_servers = self.dsdns.get_SRV_records(tcp_host) if udp_kerberos_master_servers: kerberos_master_servers += udp_kerberos_master_servers for kms in kerberos_master_servers: logger.debug("get_kerberos_master_servers: found %s", kms) return kerberos_master_servers def get_kerberos_admin_servers(self, domain, proto='tcp'): kerberos_admin_servers = [] if not domain: return kerberos_admin_servers if proto is None: proto = ['tcp', 'udp'] if 'tcp' in proto: tcp_host = "_kerberos-adm._tcp.%s" % domain logger.debug("get_kerberos_admin_servers: tcp_host = %s", tcp_host) tcp_kerberos_admin_servers = self.dsdns.get_SRV_records(tcp_host) if tcp_kerberos_admin_servers: kerberos_admin_servers += tcp_kerberos_admin_servers if 'udp' in proto: udp_host = "_kerberos-adm._tcp.%s" % domain logger.debug("get_kerberos_admin_servers: udp_host = %s", udp_host) udp_kerberos_admin_servers = self.dsdns.get_SRV_records(tcp_host) if udp_kerberos_admin_servers: kerberos_admin_servers += udp_kerberos_admin_servers for kms in kerberos_admin_servers: logger.debug("get_kerberos_admin_servers: found %s", kms) return kerberos_admin_servers def cache_has_ticket(self): res = False p = pipeopen("/usr/bin/klist -t") p.communicate() if p.returncode == 0: res = True return res def get_principal_from_cache(self): principal = None p = pipeopen("klist") klist_out = p.communicate() if p.returncode != 0: return None klist_out = klist_out[0] lines = klist_out.splitlines() for line in lines: line = line.strip() if line.startswith(bytes("Principal", "UTF-8")): parts = line.split(bytes(":", "UTF-8")) if len(parts) > 1: principal = parts[1].strip() return principal def get_ticket(self, realm, binddn, bindpw): krb_principal = self.get_principal_from_cache() principal = "%s@%s" % (binddn, realm) res = kinit = False if krb_principal and krb_principal.upper() == principal.upper(): return True (fd, tmpfile) = tempfile.mkstemp(dir="/tmp") os.fchmod(fd, 600) os.write(fd, bytes(bindpw, "UTF-8")) os.close(fd) args = [ "/usr/bin/kinit", "--renewable", "--password-file=%s" % tmpfile, "%s" % principal ] # XXX this needs to be configurable timeout = 30 (returncode, stdout, stderr) = run(' '.join(args), timeout=timeout) if returncode == 0: res = True if res != False: kinit = True os.unlink(tmpfile) if kinit: i = 0 while i < timeout: if self.cache_has_ticket(): res = True break time.sleep(1) i += 1 return res
class LDAP(object): class LDAPHandle(object): def __init__(self, host, binddn, bindpw): self.__host = host self.__binddn = binddn self.__bindpw = bindpw self.__ldap_handle = self.get_ldap_handle() def get_connection_handle(self, host, port, binddn, bindpw): server = ldap3.Server(host, port=port, get_info=ldap3.ALL) conn = ldap3.Connection(server, user=binddn, password=bindpw, authentication=ldap3.AUTH_SIMPLE, auto_bind=True) return conn @property def ldap_handle(self): return self.__ldap_handle def get_ldap_handle(self): return self.get_connection_handle( self.__host, 389, self.__binddn, self.__bindpw ) def __init__(self, *args, **kwargs): self.dispatcher = kwargs.get('dispatcher') self.datastore = kwargs.get('datastore') sys.path.extend(['/usr/local/lib/dsd/modules/']) from dsdns import DSDNS self.dsdns = DSDNS( dispatcher=self.dispatcher, datastore=self.datastore, ) def get_directory_type(self): return "ldap" def get_connection_handle(self, host, binddn, bindpw): return self.LDAPHandle(host, binddn, bindpw) def get_ldap_servers(self, domain): ldap_servers = [] if not domain: return dcs host = "_ldap._tcp.%s" % domain logger.debug("get_ldap_servers: host = %s", host) ldap_servers = self.dsdns.get_SRV_records(host) for lds in ldap_servers: logger.debug("get_ldap_servers: found %s", lds) return ldap_servers def get_rootDSE(self, handle): ldap_handle = handle.ldap_handle ldap_handle.search('', '(objectclass=*)', search_scope=ldap3.BASE, attributes=ldap3.ALL_ATTRIBUTES, ) if not ldap_handle.result: return None if not ldap_handle.response: return None results = ldap_handle.response[0] if not results: return None attributes = results.get('attributes', None) if not attributes: return None return attributes def get_baseDN(self, handle): rootDSE = self.get_rootDSE(handle) if not rootDSE: return None baseDN = rootDSE.get('defaultNamingContext', None) if not baseDN: return None baseDN = baseDN[0].strip() logger.debug("get_baseDN: baseDN = %s", baseDN) return baseDN def get_users(self, handle, **kwargs): ldap_handle = handle.ldap_handle baseDN = self.get_baseDN(handle) filter = '(&(|(objectclass=person)' \ '(objectclass=posixaccount)' \ '(objectclass=account))(uid=*))' logger.debug("get_users: filter = %s", filter) ldap_handle.search( baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) users = [] if not ldap_handle.result: return users filter_func = None if 'filter' in kwargs and kwargs['filter']: filter_func = kwargs['filter'] for result in ldap_handle.response: attributes = result.get('attributes', None) if not attributes: continue attributes['dn'] = result.get('dn') if filter_func: if filter_func(attributes): continue users.append(attributes) return users def get_groups(self, handle, **kwargs): ldap_handle = handle.ldap_handle baseDN = self.get_baseDN(handle) filter = '(&(|(objectclass=posixgroup)' \ '(objectclass=group))' \ '(gidnumber=*))' logger.debug("get_groups: filter = %s", filter) ldap_handle.search( baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) groups = [] if not ldap_handle.result: return groups filter_func = None if 'filter' in kwargs and kwargs['filter']: filter_func = kwargs['filter'] for result in ldap_handle.response: attributes = result.get('attributes', None) if not attributes: continue attributes['dn'] = result.get('dn') if filter_func: if filter_func(attributes): continue groups.append(attributes) return groups def get_user(self, handle, user): ldap_handle = handle.ldap_handle baseDN = self.get_baseDN(handle) if user.isdigit(): filter = '(&(|(objectclass=person)' \ '(objectclass=posixaccount)' \ '(objectclass=account))' \ '(uidnumber=%s))' % user else: filter = '(&(|(objectclass=person)' \ '(objectclass=posixaccount)' \ '(objectclass=account))' \ '(|(uid=%s)(cn=%s)))' % (user, user) logger.debug("get_user: filter = %s", filter) ldap_handle.search( baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not ldap_handle.result: return [] if not ldap_handle.response: return [] results = ldap_handle.response[0] if not results: return [] attributes = results.get('attributes', None) if not attributes: return [] if 'dn' in results: attributes['dn'] = results['dn'] return attributes def get_group(self, handle, group): ldap_handle = handle.ldap_handle baseDN = self.get_baseDN(handle) if group.isdigit(): filter = '(&(|(objectclass=posixgroup)' \ '(objectclass=group))' \ '(gidnumber=%s))' % group else: filter = '(&(|(objectclass=posixgroup)' \ '(objectclass=group))' \ '(cn=%s))' % group logger.debug("get_group: filter = %s", filter) ldap_handle.search( baseDN, filter, search_scope=ldap3.SUBTREE, attributes=ldap3.ALL_ATTRIBUTES ) if not ldap_handle.result: return [] if not ldap_handle.response: return [] results = ldap_handle.response[0] if not results: return [] attributes = results.get('attributes', None) if not attributes: return [] if 'dn' in results: attributes['dn'] = results['dn'] return attributes def get_userDN(self, handle, user): user = self.get_user(handle, user) if not user: return None userDN = user['dn'].strip() logger.debug("get_userDN: userDN = %s", userDN) return userDN def get_groupDN(self, handle, group): group = self.get_group(handle, group) if not group: return None groupDN = group['dn'].strip() logger.debug("get_groupDN: groupDN = %s", groupDN) return groupDN