NTFS Berechtigungstool mit Active Directory Gruppen Erstellung

function Set-Permission
{
[CmdletBinding()]
Param(
        [Parameter(Mandatory=$true)][String]$FullPath,
        [Parameter(Mandatory=$true)][ValidateNotNullOrEmpty()][ValidateSet($false,$true)][String]$permission_modify, #$true/$false
        [Parameter(Mandatory=$false)][ValidateNotNullOrEmpty()][ValidateSet($false,$true)][String]$permission_read = $false, #$true/$false
        [Parameter(Mandatory=$false)][String]$ou ='OU=DEMO,OU=Groups,OU=FIRMA GmbH,DC=ads,DC=FIRMA,DC=de',  
        [Parameter(Mandatory=$false)][String]$prefix = 'FS',  
        [Parameter(Mandatory=$false)][ValidateNotNullOrEmpty()][ValidateSet($false,$true)][String]$ServerName = $false, #$true/$false
        [Parameter(Mandatory=$false)][ValidateNotNullOrEmpty()][ValidateSet($false,$true)][String]$ShareName = $true, #$true/$false
        [Parameter(Mandatory=$false)][ValidateNotNullOrEmpty()][ValidateSet($false,$true)][String]$grouplowercase = $false, #$true/$false
        [Parameter(Mandatory=$false)][String]$suffix_read = 're',  
        [Parameter(Mandatory=$false)][String]$suffix_modify = 'md',  
        [Parameter(Mandatory=$false)][String]$suffix_list = 'ls',  
        [Parameter(Mandatory=$false)][String]$delimiter = '_',  
        [Parameter(Mandatory=$false)][ValidateNotNullOrEmpty()][ValidateSet("Global","Universal","DomainLocal")][String]$GroupScope = 'Global',  
        [Parameter(Mandatory=$false)][Int]$NTFSlongPath = '256'  
        )


#Globale Variablen für Backslash

$delimiter_path = "\"  
$illegal_Chars = '[&{}~#%]'  


# Active Directory Modul importieren

Import-Module ActiveDirectory

#Pfad auf illegale Zeichen prüfen
$invalid = [regex]::Matches($Fullpath, $illegal_Chars, 'IgnoreCase').Value | Sort-Object -Unique   

$Invalidfound = $invalid -ne $null
if ($InvalidFound)
{
  Write-Host "Im Pfad gefundene illegale Zeichen: $invalid" -ForegroundColor Red  
  Exit
}


#Pfad auf Länge prüfen
if ($FullPath.Name.Length -gt $NTFSlongPath)
    {
        Write-Host "$FullPath ist gößer oder gleich als $NTFSlongPath Zeichen" -ForegroundColor Red  
        Exit
    }

#Pfad auf Kleinschreibung anpassen
if($grouplowercase -eq "$true")  
    {
        $FullPath = $FullPath.ToLower()
    
        Write-Host "Kleinschreibung des Pfades aktiviert"  
    }

#FullPfad auf letztes Zeichen prüfen und bei einem \ entfernen

if($FullPath) 
    {
        if ( ($FullPath.EndsWith("\")) )  
            {
                $FullPath = $FullPath.Substring(0,($($FullPath).Length-1))
            }
    } 

#Pfad testen und wenn nicht existiert erstellen

if (!(Test-Path -Path $FullPath))
    {
        Write-Host "#############################################################"  
        Write-Host ""  
        Write-Host "Ordner oder Pfad wurden erstellt" -ForegroundColor Green  
        Write-Host ""  
        Write-Host "#############################################################"  
        New-Item -Path $FullPath -ItemType Directory -Force -InformationAction SilentlyContinue -ErrorAction SilentlyContinue
    }

#Variablen umwandeln für die Gruppenerzeugung

$SMBPath = [string]::Join('\', $FullPath.Split('\')[$($FullPath.Split('\').Length1..3)])  
$SMBPath = $SMBPath + $delimiter_path
$ServerNamePath = [string]::join("\",$FullPath.Split("\")[2])  
$ShareNamePath = [string]::join("\",$FullPath.Split("\")[3])  

$SMBPathwithdelimiter = $SMBPath -replace '\\',$delimiter  

#Erzeugung des reinen Ordnerpfades
$FolderPath = $FullPath.Replace($SMBPath,"")  


$GroupNamePath = $FolderPath -replace '\\',$delimiter  

#Gruppenbenamung anhand von Switch Parametern

#Servername in Gruppennamen

if ($ServerName -eq $true)
{
    $Prefix = "$Prefix$delimiter$ServerNamePath"  
}


#Freigabennamen in Gruppennamen

if ($ShareName -eq $true)
{
    $Prefix = "$Prefix$delimiter$ShareNamePath"  
}



$PrefixGroupNamePath = "$prefix$delimiter$GroupNamePath$delimiter"  


#Gruppe für Modify erzeugen

if ($permission_modify -eq $true)
{
    $ModifyGroupName = "$PrefixGroupNamePath$suffix_modify"  

        if (!(Get-ADGroup -filter {Name -eq $ModifyGroupName} -ErrorAction SilentlyContinue))
        { 
            Write-Host "#############################################################"  
            Write-Host ""  
            Write-Host "Gruppe $ModifyGroupName erstellt" -ForegroundColor Green  
            Write-Host ""  
            Write-Host "#############################################################"  
            New-ADGroup $ModifyGroupName -Path "$ou" -GroupCategory Security -GroupScope $GroupScope -description $FullPath -PassThru  

        }
        else 
        {
            Write-Host "#############################################################"  
            Write-Host ""  
            Write-Host "Gruppe $ModifyGroupName existiert bereits" -ForegroundColor Green  
            Write-Host ""  
            Write-Host "#############################################################"  
        }

        $Permission = [system.Security.AccessControl.FileSystemRights]"DeleteSubdirectoriesAndFiles, Write, ReadAndExecute, Synchronize"  
        $ACL = Get-Acl $FullPath
        if (!($ACL.Access.IdentityReference.Value -eq $ModifyGroupName))  
            {
                $ACLmodify = New-Object system.security.accesscontrol.filesystemaccessrule($ModifyGroupName, $Permission, 'ContainerInherit,ObjectInherit', "None", "Allow")  
                $ACL.SetAccessRule($ACLmodify) 
                Set-Acl -Path $FullPath -AclObject $ACL
                Write-Host "#############################################################"  
                Write-Host ""  
                Write-Host "Änderungsberechtigung auf $FullPath gesetzt" -ForegroundColor Green  
                Write-Host ""  
                Write-Host "#############################################################"  
            }
}



#Gruppe für Read erzeugen

if ($permission_read -eq $true)
{
    $ReadGroupName = "$PrefixGroupNamePath$suffix_read"  

        if (!(Get-ADGroup -filter {Name -eq $ReadGroupName} -ErrorAction SilentlyContinue))
        { 
            Write-Host "#############################################################"  
            Write-Host ""  
            Write-Host "Gruppe $ReadGroupName erstellt" -ForegroundColor Green  
            Write-Host ""  
            Write-Host "#############################################################"  
            New-ADGroup $ReadGroupName -Path "$ou" -GroupCategory Security -GroupScope $GroupScope -description $FullPath -PassThru  

        }
        else 
        {
            Write-Host "#############################################################"  
            Write-Host ""  
            Write-Host "Gruppe $ReadGroupName existiert bereits" -ForegroundColor Green  
            Write-Host ""  
            Write-Host "#############################################################"  
        }

        $Permission = [system.Security.AccessControl.FileSystemRights]"ReadAndExecute, Synchronize"  
        $ACL = Get-Acl $FullPath
        if (!($ACL.Access.IdentityReference.Value -eq $ReadGroupName))  
            {
                $ACLread = New-Object system.security.accesscontrol.filesystemaccessrule($ReadGroupName, $Permission, 'ContainerInherit,ObjectInherit', "None", "Allow")  
                $ACL.SetAccessRule($ACLread) 
                Set-Acl -Path $FullPath -AclObject $ACL
                Write-Host "#############################################################"  
                Write-Host ""  
                Write-Host "Leseberechtigung auf $FullPath gesetzt" -ForegroundColor Green  
                Write-Host ""  
                Write-Host "#############################################################"  
            }
}



#Gruppen für List erzeugen

#Ordner in Array schreiben bei Trennung \

$folderarray = $FolderPath.Split("\")  

#Anzahl Arrayelemente eins abziehen, da für den letzten Ordner kein List Recht benötigt werden, da dieser bereits die Read oder Modify Rechte besitzt 

$folderarray_count = $folderarray.Count - 1

#Zusammensetzten des vorderen Teils des Gruppennamnes

$GroupList_Base = "$prefix$delimiter"  

#SMBPfad auf letztes Zeichen prüfen und bei einem \ entfernen

if($SMBPath) 
{
if ( ($SMBPath.EndsWith("\")) )  
    {
       $ListPath_Base =   $SMBPath.Substring(0,($($SMBPath).Length-1))
    }
} 



#Variable mit leerem Array bilden

$ListGroupArray = @()

#Solange Schleife durchführen, bis eins weniger als die Ordneranzahl erreicht ist
for($i=0; $i -lt $folderarray_count; $i++)
{
    #Zusammenbauen des Gruppennamens mit Ordnernamen und delimiter

    $GroupList_Base= $GroupList_Base + $folderarray[$i] + $delimiter

    #Zusammenbauen des Gruppennamens mit Suffix für Listgruppen

    $ListGroupName = $GroupList_Base + $suffix_list

    $ListGroupArray += $ListGroupName

    #Pfad für das setzten der Listrechte zusammenbauen
    $ListPath_Base= $ListPath_Base + $delimiter_path + $folderarray[$i]



        # List Gruppe erstellen

       if (!(Get-ADGroup -filter {Name -eq $ListGroupName} -ErrorAction SilentlyContinue))
        { 
            Write-Host "#############################################################"  
            Write-Host ""  
            Write-Host "Gruppe $ListGroupName erstellt" -ForegroundColor Green  
            Write-Host ""  
            Write-Host "#############################################################"  
            New-ADGroup $ListGroupName -Path "$ou" -GroupCategory Security -GroupScope $GroupScope -description $ListPath_Base -PassThru  
        }
        else 
        {
            Write-Host "#############################################################"  
            Write-Host ""  
            Write-Host "Gruppe $ListGroupName existiert bereits" -ForegroundColor Blue  
            Write-Host ""  
            Write-Host "#############################################################"      
        }

        #List Gruppen berechtigen

        $Permission = [system.Security.AccessControl.FileSystemRights]"ReadAndExecute,Synchronize"  
        $ACL = Get-Acl $ListPath_Base
             if (!($ACL.Access.IdentityReference.Value -eq $ListGroupName))  
            {
                    $ACLlist = New-Object system.security.accesscontrol.filesystemaccessrule($ListGroupName, $Permission, "None", "None", "Allow")  
                    $ACL.SetAccessRule($ACLlist) 
                    Set-Acl -Path $ListPath_Base -AclObject $ACL
                    Write-Host "#############################################################"  
                    Write-Host ""  
                    Write-Host "Listberechtigung auf $ListPath_Base gesetzt" -ForegroundColor Green  
                    Write-Host ""  
                    Write-Host "#############################################################"  
             }




}

# Modify und/oder Read Gruppen der nächst höhren liegenden Listgruppe hinzufügen

$ListGroupArray_Count = $ListGroupArray.Count

if($ListGroupArray_Count -gt 0)
{

    if($permission_modify -eq $true)
    {
        Add-ADPrincipalGroupMembership -Identity $ModifyGroupName -Memberof $ListGroupArray[$ListGroupArray_Count-1]
        Write-Host "#############################################################"  
        Write-Host ""  
        Write-Host $ModifyGroupName -ForegroundColor Green
        Write-Host "in" -ForegroundColor Green  
        Write-Host $ListGroupArray[$ListGroupArray_Count-1] -ForegroundColor Green
        Write-Host "hinzugefügt" -ForegroundColor Green  
        Write-Host ""  
        Write-Host "#############################################################"  
    }

    if($permission_read -eq $true)
    {
        Add-ADPrincipalGroupMembership -Identity $ReadGroupName -Memberof $ListGroupArray[$ListGroupArray_Count-1]
        Write-Host "#############################################################"  
        Write-Host ""  
        Write-Host $ReadGroupName -ForegroundColor Green
        Write-Host "in" -ForegroundColor Green  
        Write-Host $ListGroupArray[$ListGroupArray_Count-1] -ForegroundColor Green
        Write-Host "hinzugefügt" -ForegroundColor Green  
        Write-Host ""  
        Write-Host "#############################################################"  
    }
}

#List Gruppe mit der darüberliegenden List Gruppe verschachteln

for($i = $ListGroupArray_Count - 1; $i-gt 0; $i--)
{
    Add-ADPrincipalGroupMembership -Identity $ListGroupArray[$i] -Memberof $ListGroupArray[$i-1]
    Write-Host "#############################################################"  
    Write-Host ""  
    Write-host $ListGroupArray[$i] -ForegroundColor Green
    Write-Host "in" -ForegroundColor Green  
    Write-Host $ListGroupArray[$i-1] -ForegroundColor Green
    Write-Host "hinzugefügt" -ForegroundColor Green  
    Write-Host ""  
    Write-Host "#############################################################"  
}
Write-Host "#############################################################"  
Write-Host ""  
Write-Host "Berechtigungen erfolgreich gesetzt" -ForegroundColor Green  
Write-Host ""  
Write-Host "#############################################################"  
}

function Get-PermissionsPathScanner
{
[CmdletBinding()]
Param( 
        [Parameter(Mandatory=$true)][String]$FullPath,
        [Parameter(Mandatory=$false)][String]$NetBiosDomain = "NETBIOSDOMAIN",  
        [Parameter(Mandatory=$false)][String]$Reportpath = "$Fullpath",  
        [Parameter(Mandatory=$false)][Int]$Depth
    )


$NetBiosDomain = $NetBiosDomain + "\\"  

$result = @()


if (!($Depth))
{
$ChildPathes = Get-ChildItem -Path $FullPath -Directory -Recurse
}
else 
{
$ChildPathes = Get-ChildItem -Path $FullPath -Directory -Depth $Depth 
}

foreach ($ChildPath in $Childpathes)
{
$ACL = Get-Acl $ChildPath.FullName
$ACEs = $ACL.GetAccessRules($true, $false ,[System.Security.Principal.NTAccount])

foreach ($ACE in $ACEs)
{
 $ADGroup = $ACE.IdentityReference 
 $ADGroup = $ADGroup.Value -replace $NetBiosDomain,''  
 $GroupDescription = Get-ADGroup $ADGroup -Properties Name, description | select description

 if (!($ChildPath.FullName -eq $GroupDescription.description))
 {

    $tempobject = New-Object PSCustomObject

    $tempobject | Add-Member -type NoteProperty -Name Pfad -Value $ChildPath.FullName
    $tempobject | Add-Member -type NoteProperty -Name ADGruppe -Value $ADGroup
    $tempobject | Add-Member -type NoteProperty -Name Gruppenbeschreibung -Value $GroupDescription.description

            $result += $tempobject
    }
}
$Header = @"  
"@  
$result | ConvertTo-Html -as List -Title "Gruppe passt nicht zu Pfad" -Property Pfad,ADGruppe,Gruppenbeschreibung | Out-File -FilePath "$Reportpath\Report.html"  
}
}