Script extraction AD (users, groups, GPO)

######################################
#         Script  Extraction AD           
# PowerShell v4                            #
############################################

$ErrorActionPreference = ‘SilentlyContinue’
#$ErrorActionPreference = « SilentlyContinue » #Erreurs non affichées et exécution se poursuit sans interruption

#\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\#
#                    Import des modules PowerShell                     #
#//////////////////////////////////////////////////////////////////////#

Import-module -Name ActiveDirectory
Import-module -Name GroupPolicy

#\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\#
#                   Initialisation des Variables                       #
#//////////////////////////////////////////////////////////////////////#

$dicGroupGPO = @{}
$dicoToken = @{}
$ADDomain = get-addomain
$sDomainName = $ADDomain.DNSRoot
$oLDAPGroups = $oListGroup

# Variables pour les fichiers à créer
$Pathprojet = « C:\serveur_apps\scripts\projet »
$GroupGPOAD = $Pathprojet + « \GroupGPOAD_xyz.csv »
$sxyzFilePath1 = $Pathprojet + « \UserListAD_xyz.csv »
$sxyzFilePath2 = $Pathprojet + « \UserGroupAD_xyz.csv »
$sxyzFilePath3 = $Pathprojet + « \temp.tmp »
$GPOfileOut = $Pathprojet + « \GPO.txt »

# Variables pour les logs
$dDateCourante = Get-Date
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss »)+  » INFO – Début d’exécution  »
$sLogFile = « C:\scripts\projetlog\log.txt »

#\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\#
#                 Initialisation des Fonctions                         #
#//////////////////////////////////////////////////////////////////////#
# Fonction pour convertir un chemin LDAP en canonical / le nom du groupe n’est pas gardé dans la valeur de retour
Function ConverTprojetnonicalName ($strToConvert,$sDomain)
{
$canonicalname = $sDomain + « / »
$liste = $strToConvert -split « , »
For ($i = -1 ; $i -gt -$liste.count; $i — )
{
if (($liste[$i]).substring(0,3) -eq « OU= ») {
$canonicalname +=  ($liste[$i]).substring(3,($liste[$i]).length-3) + « / »

}
if (($liste[$i]).substring(0,3) -eq « CN= ») {
$canonicalname +=  ($liste[$i]).substring(3,($liste[$i]).length-3) + « / »
}
}
return $canonicalname
$canonicalname = $Null
}

# Fonction retournant les sous groupes d’un groupe
function Get-GroupHierarchy ($SearchGroup, $sGPO)
{
If ($searchGroup -ne «  »)
{
If ($dicGroupGPO.ContainsKey($searchGroup))
{
$aGroupMember = $dicGroupGPO.Get_Item($searchGroup)
ForEach ($groupmember in $aGroupMember)
{
$strGroupmember = $groupmember.name
$strGroupmemberDNWithoutGroupName = $groupmember.DistinguishedName
$strGroupmemberCN = ConverTprojetnonicalName $strGroupmemberDNWithoutGroupName $sdomainName
« $strGroupmember;$sGPO;$strGroupmemberCN » | Out-File -Append -FilePath $sxyzFilePath3 -Encoding Unicode
}
}
Else
{
$groupMembers = get-adgroupmember $searchGroup | where {$_.ObjectClass -eq « group »} #| select-object name
If ($groupMembers)
{
$dicGroupGPO.add($searchGroup,$groupMembers)
Foreach ($groupmember in $groupMembers)
{
$strGroupmember = $groupmember.name
$strGroupmemberDNWithoutGroupName = $groupmember.DistinguishedName
$strGroupmemberCN = ConverTprojetnonicalName $strGroupmemberDNWithoutGroupName $sdomainName
« $strGroupmember;$sGPO;$strGroupmemberCN » | Out-File -Append -FilePath $sxyzFilePath3 -Encoding Unicode
Get-GroupHierarchy $strGroupmember $sGPO
} # foreach $groupmembers
} #If $groupMembers
} #else
}#if($dicGroupGPO.ContainsKey($searchGroup))
} # end of function

#\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\#
#                    Vérification du répertoire                        #
#//////////////////////////////////////////////////////////////////////#

# Répertoire pour les fichiers de log
If(!(Test-Path $sLogFile ))
{
$sresult = New-Item $sLogFile -type directory
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » INFO – SUCCES Le répertoire  » + $Pathprojet +  » a été créé »
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
}

# Réroire pour les fichiers d’extraction
If(!(Test-Path $Pathprojet))
{
Try
{
$sresult = New-Item $Pathprojet -type directory
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » INFO – SUCCES Le répertoire  » + $Pathprojet +  » a été créé »
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
}
Catch
{
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ERREUR – Création du répertoire  » + $Pathprojet +  » impossible »
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
ForEach($ErreurMessage in $Error)
{
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ERREUR –  » + ($ErreurMessage.ToString()).Replace(« `n », » »)
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
}
$Error.clear()
}
}

#\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\#
#                      Extraction données                              #
#//////////////////////////////////////////////////////////////////////#

# Vérification de la présence des fichiers, suppressions si « true »
If(Test-Path $sxyzFilePath1){remove-item -path $sxyzFilePath1 -Force}
If(Test-Path $sxyzFilePath2){remove-item -path $sxyzFilePath2 -Force}
If(Test-Path $sxyzFilePath3){remove-item -path $sxyzFilePath3 -Force}
If(Test-Path $GroupGPOAD){remove-item -path $GroupGPOAD -Force}
If(Test-Path $GPOfileOut){remove-item -path $GPOfileOut -Force}

######### Création du fichier groupe GPO #########
# Extraction des GPO dans un fichier puis une variable
$oListGPOS = Get-gpo -all | format-table DisplayName -HideTableHeaders | out-file $GPOfileout
$oListGPOS = Get-Content $GPOfileout
$sResult = New-Item $sxyzFilePath3 -type file -force

# Préparation du fichier GPO, entêtes
$sOutPutMess = « Nom du groupe;Nom de la GPO;OU Group »
$sOutPutMess | Out-File -Append -FilePath $GroupGPOAD  -Encoding Unicode
$Error.clear()

Foreach ($oListGPO in $oListGPOS) # Début de traitement du tableau utilisateur et GPO
{
$Error.clear()
Try
{
$oListGPO = ($oListGPO).trim()
$oListPERMISSIONS = Get-GPPermissions -Name $oListGPO -All -DomainName $sDomainName

# Check des permissions sur chaque GPO
Foreach ($sListPERMISSION in $oListPERMISSIONS )
{
If(($sListPERMISSION.Permission -eq « GpoApply ») -and ($sListPERMISSION.Trustee.Name -ne « Utilisateurs authentifiés »))
{
# S’il y a un utilisateur ou ordinateur directement dans le filtre GPO
If (($sListPERMISSION.Trustee.SIDType -eq « User ») -or ($sListPERMISSION.Trustee.SIDType -eq « Computer »))
{
$sGPOMessage = « ATTENTION  » + $sListPERMISSION.Trustee.SIDType +  »  » + $sListPERMISSION.Trustee.Name + « ; » + $oListGPO
$sGPOMessage | Out-File -Append -FilePath $sxyzFilePath3  -Encoding Unicode
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ATTENTION – Des utilisateurs ou ordinateurs sont directement rattachés à la GPO :’$oListGPO’. Fichier :   » + $sxyzFilePath3
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
}
ElseIf ($sListPERMISSION.Trustee.SIDType -eq « Unknown »)
{
$sGPOMessage = « ATTENTION Groupe ou utilisateur inexistant; » + $oListGPO
$sGPOMessage | Out-File -Append -FilePath $sxyzFilePath3  -Encoding Unicode
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ATTENTION – Groupe ou utilisateur inexistant pour la GPO : ‘$oListGPO’ Fichier : $sxyzFilePath3″
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
}
Else
{
$strDSPathGroupe = $sListPERMISSION.Trustee.DSPath
$strCNGroupe = ConverTprojetnonicalName $strDSPathGroupe $sdomainName
$sGPOMessage = $sListPERMISSION.Trustee.Name + « ; » + $oListGPO + « ; » + $strCNGroupe
$sGPOMessage | Out-File -Append -FilePath $sxyzFilePath3  -Encoding Unicode
Get-GroupHierarchy $sListPERMISSION.Trustee.Name $oListGPO
}
}
} #Foreach ($sListPERMISSION in $oListPERMISSIONS )
} # Try
Catch
{
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ERREUR – Problème de traitement du fichier, GPO : ‘$oListGPO’  dans  » + $sxyzFilePath3 +  » pour  » + $GroupGPOAD
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
ForEach($ErreurMessage in $Error)
{
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ERREUR –  » + ($ErreurMessage.ToString()).Replace(« `n », » »)
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
}
$Error.clear()
}
} #Foreach ($oListGPO in $oListGPOS)

# Tri pour avoir unicite des resultats
# le passage par un fichier temporaire et un tri est preferable à l utilisation d’un tableau pour de nombreuses donnees
Get-Content $sxyzFilePath3 | sort | Get-Unique | out-file -Append -FilePath $GroupGPOAD -Encoding Unicode

######### Requètes des utilisateurs #########
$oLDAPUsers = Get-ADUser -filter * –properties SamAccountName,Surname,GivenName,DistinguishedName,whencreated,Enabled,LockedOut,LastLogonDate,PasswordNeverExpires,PasswordLastSet,CannotChangePassword,PasswordNotRequired,AccountLockoutTime,LockedOut
Get-GroupHierarchy $sListPERMISSION.Trustee.Name $oListGPO

######### Requètes des groupes #########
$oListGroup = Get-ADGroup -filter * -Properties SamAccountName

# Construction des fichiers utilisateurs et groupes : new file ; création des entetes, logs,
If($oLDAPUsers -And $oLDAPGroups)
{
# Création des fichiers, des entetes et écritures dans le log
$sresult = New-Item $sxyzFilePath1 -type file # Création du nouveau fichier ‘xyz_UserListAD.csv’
$sOutPutMess = « Identifiant;Nom;Prenom;DN du compte;Date de creation du compte;Date derniere modification du compte;Statut Actif;Compte verrouillé;Date derniere connexion du compte;Mot de passe expiré;Derniere modification du mot de passe;Mot de passe permanent;Mot de passe optionnel;Date d expiration;Duree depuis le verrouillage;Nombre de mauvais mot de passe ;Mot de passe verrouillé;Changement de mot de passe au prochain demarrage »
$sOutPutMess | Out-File -Append -FilePath $sxyzFilePath1 -Encoding Unicode
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » INFO – Début de traitement du fichier  » + $sxyzFilePath1
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode

$sresult = New-Item $sxyzFilePath2 -type file # Création du nouveau fichier 2
$sOutPutMess = « Identifiant;Domaine;Ressources »
$sOutPutMess | Out-File -Append -FilePath $sxyzFilePath2 -Encoding Unicode
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » INFO – Début de traitement du fichier  » + $sxyzFilePath2
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode

$iValue = 0x02
$oCultureInfo = New-Object System.Globalization.CultureInfo(« fr-FR »)

Foreach ($oLDAPUser in $oLDAPUsers) # Début de traitement du tableau utilisateur
{
$Error.clear()
Try
{
$sSAMAcName = $oLDAPUser.samaccountname
$sLastName = $oLDAPUser.sn
$sFirstName = $oLDAPUser.givenname

$sdistinguishedName = $oLDAPUser.distinguishedname
#DN du compte sans le nom de l’utilisateur, valeur ‘DN du compte’ dans le fichier $sxyzFilePath1
$sDistinguishedNameWithoutUserName = ($sdistinguishedName -split(« , »,2))[1]

#En remplacement du ‘Get-ACL’ et ‘récup compte verrouillé’
$sUserProperties = Get-ADUser -SearchScope Base -SearchBase $sdistinguishedName -Filter * -Properties CannotChangePassword,LockedOut,PasswordExpired -Server $sDomainName

$sPwdProtected = $sUserProperties.CannotChangePassword

If($oLDAPUser.whencreated) #format date
{
$sWhenCreated = [datetime]::Parse($oLDAPUser.whencreated.ToString())
$dWhenCreated = ($sWhenCreated.ToLprojetlTime()).ToString(« G », $oCultureInfo)
}
Else {$dWhenCreated = $Null}

If($oLDAPUser.whenchanged) #format date
{
$sWhenChanged = [datetime]::Parse($oLDAPUser.whenchanged.ToString())
$dWhenChanged = ($sWhenChanged.ToLprojetlTime()).ToString(« G », $oCultureInfo)
}
Else {$dWhenChanged = $Null}

If($oLDAPUser.lastlogontimestamp) #format int
{
$dLastLogOn = [datetime]::FromFileTime([Int64]::Parse($oLDAPUser.lastlogontimestamp))
$sLastLogOn = $dLastLogOn.ToString(« G », $oCultureInfo)
}
Else {$sLastLogOn = $Null}

$sUserAccountLocked = $sUserProperties.LockedOut

If($oLDAPUser.lockouttime -gt 0) #format int
{
$sLastlockoutTime = [datetime]::FromFileTime([Int64]::Parse($oLDAPUser.lockouttime))
$dLastlockoutTime = $sLastlockoutTime.ToString(« G », $oCultureInfo)
}
Else {$dLastlockoutTime = «  »}

$sPasswordExpired = $sUserProperties.PasswordExpired

If(($oLDAPUser.pwdlastset -ne 0) -and ($oLDAPUser.pwdlastset -ne $NULL)) #format int
{
$spwdLastSet = [datetime]::FromFileTime([Int64]::Parse($oLDAPUser.pwdlastset))
$dpwdLastSet = $spwdLastSet.ToString(« G », $oCultureInfo)
$spwdToInitialize = « False »
}
Else
{
$spwdToInitialize = « True »
$dpwdLastSet = «  »
}

$DONT_EXPIRE_PASSWORD = 65536
If($oLDAPUser.useraccountcontrol)
{
If($oLDAPUser.useraccountcontrol.Value -band $DONT_EXPIRE_PASSWORD) {$sPwdPermanent = « True »}
Else {$sPwdPermanent = « False »}
}
Else {$sPwdPermanent = « False »}

$PASSWORD_NOT_REQUIRED = 32
If($oLDAPUser.useraccountcontrol)
{
If($oLDAPUser.useraccountcontrol.Value -band $PASSWORD_NOT_REQUIRED) {$sPwdNotRequired = « True »}
Else {$sPwdNotRequired = « False »}
}
Else {$sPwdNotRequired = « False »}

If (($oLDAPUser.accountexpires -ne 0) -and ($oLDAPUser.accountexpires -ne $NULL) -and ($oLDAPUser.accountexpires -le [DateTime]::MaxValue.Ticks))
{
$saccountExpires = [datetime]::FromFileTime([Int64]::Parse($oLDAPUser.accountexpires))
$daccountExpires = $saccountExpires.ToString(« G », $oCultureInfo)
}
Else {$daccountExpires = «  »}

$sbadPwdCount = $oLDAPUser.badpwdcount

$ACCOUNT_DISABLE = 2
If($oLDAPUser.useraccountcontrol)
{
If($oLDAPUser.useraccountcontrol -band $ACCOUNT_DISABLE) {$sUserAcControl = « Disabled »}
Else {$sUserAcControl = « Enabled »}
}
Else {$sUserAcControl = $Null}

$aGroupMembers = Get-ADUser -SearchScope Base -SearchBase $oLDAPUser.distinguishedname -LDAPFilter ‘(objectClass=user)’ -Properties tokenGroups -Server $sDomainName| Select-Object -ExpandProperty tokenGroups | Select-Object -ExpandProperty Value

ForEach($tokenGroup In $aGroupMembers)
{
Try
{
If($sSAMAcName)
{
If ($dicoToken.ContainsKey($tokenGroup))
{
$sGroupPath_strNameTokenGroup = $dicoToken.Get_Item($tokenGroup)
$sOutPutMess = « $sSAMAcName;$sGroupPath_strNameTokenGroup »
$sOutPutMess | Out-File -Append -FilePath $sxyzFilePath2 -Encoding Unicode
}
Else
{
$strTokenGroupIndentity = Get-ADGroup -Identity $tokenGroup -Server $sDomainName
$strNameTokenGroup = $strTokenGroupIndentity.Name
$strDistNameTokenGroup = $strTokenGroupIndentity.DistinguishedName
$sGroupPath = ConverTprojetnonicalName $strDistNameTokenGroup $sdomainName
$sOutPutMess = « $sSAMAcName;$sGroupPath;$strNameTokenGroup »
$sOutPutMess | Out-File -Append -FilePath $sxyzFilePath2 -Encoding Unicode
$strGroupForDico = « $sGroupPath;$strNameTokenGroup »
$dicoToken.Add($tokenGroup,$strGroupForDico)
}
}#If($sSAMAcName)
} # try
Catch
{
ForEach($ErreurMessage in $Error)
{
If (!(($ErreurMessage.CategoryInfo.Category -eq « ObjectNotFound ») -and ($ErreurMessage.CategoryInfo.Reason -eq « ADIdentityNotFoundException »)))
{
$sOutPutMess = « ATTENTION PROBLEME sur utilisateur $sSAMAcName et le groupe $tokenGroup (Partie Début de traitement du tableau utilisateur du script) »
$sOutPutMess | Out-File -Append -FilePath $sxyzFilePath2 -Encoding Unicode
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ATTENTION PROBLEME – sur utilisateur $sSAMAcName dans fichier $sxyzFilePath2″ +  » Partie Début de traitement du tableau utilisateur du script »
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ERREUR NON BLOQUANTE –  » + ($ErreurMessage.ToString()).Replace(« `n », » ») + « Partie Début de traitement du tableau utilisateur du script »
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
}
Else
{
$objSID = New-Object System.Security.Principal.SecurityIdentifier ($tokenGroup)
$objUser = $objSID.Translate( [System.Security.Principal.NTAccount])

$sOutPutMess = « $sSAMAcName;$objUser;$tokenGroup »
$sOutPutMess | Out-File -Append -FilePath $sxyzFilePath2 -Encoding Unicode
}
} # foreach
$Error.clear()
} #catch
If($sSAMAcName) # Ajout des données de l’utilisateur en cours de traitement dans le fichier 1 xyz
{
$sOutPutMess = « $sSAMAcName;$sLastName;$sFirstName;$sdistinguishedNameWithoutUserName;$dWhenCreated;$dWhenChanged;$sUserAcControl;$sUserAccountLocked;$sLastLogOn;$sPasswordExpired;$dpwdLastSet;$sPwdPermanent;$sPwdNotRequired;$daccountExpires;$dLastlockoutTime;$sbadPwdCount;$sPwdProtected;$spwdToInitialize »
$sOutPutMess | Out-File -Append -FilePath $sxyzFilePath1 -Encoding Unicode
}
} #ForEach($tokenGroup In $aGroupMembers)
}#Try de Foreach ($oLDAPUser in $oLDAPUsers)
Catch
{
$sOutPutMess = « ATTENTION PROBLEME sur utilisateur $sSAMAcName;$sLastName;$sFirstName;$sdistinguishedNameWithoutUserName;$dWhenCreated;$dWhenChanged;$sUserAcControl;$sUserAccountLocked;$sLastLogOn;$sPasswordExpired;$dpwdLastSet;$sPwdPermanent;$sPwdNotRequired;$daccountExpires;$dLastlockoutTime;$sbadPwdCount;$sPwdProtected;$spwdToInitialize »
$sOutPutMess | Out-File -Append -FilePath $sxyzFilePath1 -Encoding Unicode
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ATTENTION PROBLEME – sur utilisateur $sSAMAcName dans fichier $sxyzFilePath1″
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
ForEach($ErreurMessage in $Error)
{
$sLogMessage = (Get-Date).ToString(« dd/MM/yyyy HH:mm:ss ») +  » ERREUR NON BLOQUANTE –  » + ($ErreurMessage.ToString()).Replace(« `n », » »)
$sLogMessage | Out-File -Append -FilePath $sLogFile -Encoding Unicode
}
$Error.clear()
} # catch
} #Foreach ($oLDAPUser in $oLDAPUsers) # tableau utilisateur
} #If($oLDAPUsers -And $oLDAPGroups)

# Suppresion des fichiers temporaires
$ErrorActionPreference = ‘SilentlyContinue’
If(!(Test-Path $sxyzFilePath3)){Remove-Item $sxyzFilePath3}
If(!(Test-path $GPOfileout)){Remove-Item $GPOfileout}
#If(!(Test-path $sxyzFilePath3)){
Remove-Item $sxyzFilePath3

Laisser un commentaire