The Difference Between PowerShell ADSI and ADSISearcher

Other Posts in this Series:

This post will examine the difference between PowerShell ADSI and ADSISearcher when using PowerShell to query Active Directory.

ADSI and ADSISearcher are used to query Active Directory (AD) using Lightweight Directory Access Protocol (LDAP).

What is LDAP?

LDAP, as the name suggests, is a protocol that provides an interface to query AD directory services.  When we are querying AD we are returning one or more objects with unique identifiers (a Distinguished Name).  And we can do this using two type accelerators called ADSI and ADSISearcher.

What is a Type Accelerator?

A type accelerator is a simple alias to represent a .Net class.  We can return a list of type accelerators like so:

[System.Management.Automation.PSObject].Assembly.GetType("System.Management.Automation.TypeAccelerators")::Get

You’ll notice that one of the type accelerators is psobject which references the class System.Management.Automation.PSObject. This means we could simplify our command above by using a type accelerator to get a list of all the type accelerators like so!

[psobject].Assembly.GetType("System.Management.Automation.TypeAccelerators")::Get

What is ADSISearcher?

[ADSISearcher] is a type accelerator for the class System.DirectoryServices.DirectorySearcher.  It is used to search for one or more objects based on a filter.

Consider this example, where we want to search all objects in AD and filter by user objects only:

$objSearcher=[adsisearcher]'(&(objectCategory=person)(objectClass=user))'

Or perhaps filter by only computers:

$objSearcher=[adsisearcher]'(&(objectCategory=computer))'

We can also get more complex by filtering for only enabled user objects in AD by adding a filter for the userAccountControl:

$objSearcher=[adsisearcher]'(&(objectCategory=person)(objectClass=user)(!userAccountControl:1.2.840.113556.1.4.803:=2))'

And if we wanted to loop through all the enabled users we could do this:

$objSearcher=[adsisearcher]'(&(objectCategory=person)(objectClass=user)(!userAccountControl:1.2.840.113556.1.4.803:=2))'

#specify page size to optimise caching memory required on DC
$objSearcher.PageSize = 200

#speed up the search by specifying only the properties we need
$colProplist = "distinguishedname"
foreach ($i in $colPropList) { $objSearcher.PropertiesToLoad.Add($i) | out-null } 

#use FindAll since we will potentially return many results
$colResults = $objSearcher.FindAll()

if ($colResults -ne $null) { 
    foreach($colResult in $colResults) {
        write-host ($colResult.Properties).distinguishedname
    }
}

We could also search for a single, specific user like so:

$objSearcher=[adsisearcher]'(&(objectCategory=person)(objectClass=user)(sAMAccountName=alkaneuser))'

And we could perform a simple search for this single user like so:

$objSearcher=[adsisearcher]'(&(objectCategory=person)(objectClass=user)(sAMAccountName=alkaneuser))'

#use FindOne since we're only returning a single result
$colResults = $objSearcher.FindOne()

if ($colResults -ne $null) { 
    write-host ($colResults.Properties).distinguishedname
}

All of the above searches are used to query the whole of AD.  But what if we wanted to only query a single object?  For example, an AD group?

What is ADSI?

[ADSI] is a type accelerator that represents the class System.DirectoryServices.DirectoryEntry.  It is used to bind directly to objects such as an AD group, an AD user or an AD computer.  It can then be used to update the attributes for a particular object.

In the above example, when we perform a search using FindOne() or FindAll() it returns one or many System.DirectoryServices.SearchResults.  We cannot modify the attributes of a search result – we use search results to simply print out attributes that we’re interested in.

If we wanted to update an attribute for an object returned as a search result, we need to create an ADSI object from this search result like so:

$objSearcher=[adsisearcher]'(&(objectCategory=person)(objectClass=user)(sAMAccountName=alkaneuser))'
$colResults = $objSearcher.FindOne()

if ($colResults -ne $null) { 
    
    #get path of the object from search result
    $pathToObject = ($colResults.Properties).adspath[0]

    #convert/cast search result object path to an ADSI object
    $user = [adsi]($pathToObject)

    #update the department
    $user.PutEx(1, "department", "alkane dept");

    #save it
    $user.SetInfo()
}

In the above example, we update the department attribute for a user called alkaneuser and set it to “alkane dept”.

Use PowerShell ADSI to Migrate AD Group Members

Other Posts in this Series:

UPDATE: I’ve updated this script because LDAP does not return all Active Directory group members if there are more than 1500 members in the group.

This post provides a function which enables us to use PowerShell ADSI to migrate AD group members. We can also specify whether to copy or move the group members.

function  Get-ADGroupMembers {
    param ([string]$adgroup)
      
    $searcher=[adsisearcher]""
    $searcher.Filter="(&(objectClass=group)(cn=$adgroup))"
    $searcher.PageSize=200
    
    #find group   
    $result=$searcher.FindOne()

    #if group found
    if ($result) {
                 
        #if range exists because group is large
        $moreThan1500Members = [bool]($result.Properties.PropertyNames | where { $_ -like "member;range=*" })

        #if group has more than 1500 members
        if($moreThan1500Members) {     
   
            #we need to recurse through ranges
            $iteratedAllRanges=$false
            $rangeBottom =0
            $rangeTop= 0
    
            while (!($iteratedAllRanges)) {

               $rangeTop=$rangeBottom + 1499

               #set new range
               $memberRange="member;range=$rangeBottom-$rangeTop"
               $searcher.PropertiesToLoad.Clear()
               [void]$searcher.PropertiesToLoad.Add("$memberRange")
               
               try {

                    #if range invalid, throw exception
                    $result = $searcher.FindOne()
                    $rangedProperty = $result.Properties.PropertyNames -like "member;range=*"
                    $members +=$result.Properties.item($rangedProperty)

                    if ($members.count -eq 0) { $iteratedAllRanges=$true }

               } catch {
                    $iteratedAllRanges=$true
               }

               #increment bottom of range for next iteration
               $rangeBottom+=1500

            }
        } else {
            #group member count is less than 1500
            $members += $result.properties.item("member")
        }

        $searcher.Dispose()
        return $members

    }

    return $false   
}


function Migrate-ADGroup
{
    Param
    (
       [string]$sourceDN, 
       [string]$targetDN,
       [bool]$move
    )
   
   if (!([adsi]::Exists("LDAP://$sourceDN"))) {
        write-host "$sourceDN does not exist"
        return     
   }
 
   if (!([adsi]::Exists("LDAP://$targetDN"))) {
        write-host "$targetDN does not exist"
        return
   }

    $sourceDNADSI = [ADSI]"LDAP://$sourceDN"
    $targetDNADSI = [ADSI]"LDAP://$targetDN"

    try {
        $count = 0;

        Get-ADGroupMembers ($sourceDNADSI.Name) | ForEach-Object {
    
            $count++
            $groupObject = [adsisearcher]"(distinguishedname=$($_))"   

            if ($move) {
                write-host "Moving $($groupObject.FindOne().Properties.name)"
                try { $targetDNADSI.Add("LDAP://$_") } catch {}
                try { $sourceDNADSI.Remove("LDAP://$_") } catch {}
            } else {
                write-host "Copying $($groupObject.FindOne().Properties.name)"
                try { $targetDNADSI.Add("LDAP://$_") } catch {}
            }
        }
        write-host "Processesed $count objects"

    } catch {
        write-host $_.Exception.Message
    }
}

$sourcegroup = "CN=application1,OU=Apps,DC=alkanesolutions,DC=co,DC=uk"
$targetgroup = "CN=application2,OU=Apps,DC=alkanesolutions,DC=co,DC=uk"

#source group to migrate from, target group to migrate to, false (copy members) or true (move members)
Migrate-ADGroup $sourcegroup $targetgroup $false

Use ADSI to Find Logon Workstations in Active Directory

Other Posts in this Series:

This post provides an example of how we can use ADSI to find logon workstations in Active Directory.

I recently needed to search through all users in Active Directory and find logon workstations for those accounts that had them.  Logon workstations for a user account essentially restricts what workstations a specific user account can log on to.

A lot of this code example is based on using the ADSI Searcher to find user accounts in Active Directory.

$Root = [ADSI]"LDAP://OU=users,DC=alkanesolutions,DC=co,DC=uk"
$Searcher = new-object System.DirectoryServices.DirectorySearcher($Root)
$Searcher.filter = "(&(objectCategory=person)(objectClass=user))"
$Searcher.PageSize = 200

$Searcher.FindAll() | % {
  
    $user = [adsi]$_.Properties.adspath[0]

    $ErrorActionPreference = "silentlycontinue"
    If (($user.get("userWorkstations")) -ne $null)
    {
        $workstations = $user.get("userWorkstations")
        $workstationsArray = $workstations.split(",")
        foreach($ws in $workstationsArray) {
            write-host $samaccount $ws
        }
    }
}

 

ADSI Searcher and the ActiveDirectory PowerShell Module

When querying Active Directory (AD) we can use a PowerShell type accelerator called the ADSI Searcher and the ActiveDirectory PowerShell Module.

Most Google searches provide examples that use the PowerShell ActiveDirectory module cmdlets such as Get-ADUser and Get-ADComputer.  Whilst these work well, they require that Remote Server Administration Tools (RSAT) is installed locally. And sometimes this prerequisite is a pain in the backside if we’re working on a machine without it.

An alternative is to use PowerShell type accelerators called ADSI and the ADSI searcher.  These type accelerators respectfully represent the classes System.DirectoryServices.DirectoryEntry and System.DirectoryServices.DirectorySearcher, and form part of the .Net framework.

We’ve created a series of tutorials starting with the difference between ADSI and ADSISearcher and expanding further to provide examples of filtering AD searches, manipulating users, groups, computers, attributes and much more.