powershellblog.com – Page 13 – Mastering PowerShell: Tips, Tricks, and Best Practices

Latest News

Why Am I Starting a PowerShell Blog? A Funny Tale

Well, folks, I think it’s time I let you in on a little secret about why I decided to start a PowerShell blog. My story is not only educational but will hopefully put a smile on your faces too!

PowerShell Tester Tool Template

10/08/2024/0 Comments/in Templates/by Laszlo Bocso

<#
.SYNOPSIS
PowerShell Tester Tool Template

.DESCRIPTION
This script provides a template for a PowerShell-based tester tool that can be customized
for various testing scenarios. It includes functions for defining tests, running them,
and generating reports.

.NOTES
File Name      : TesterToolTemplate.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\TesterToolTemplate.ps1
#>

# Global variables
$global:testResults = @()
$global:reportPath = "$env:USERPROFILE\Desktop\Test_Report_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"

<#
.SYNOPSIS
Displays the main menu of the tester tool.
#>
function Show-Menu {
    Clear-Host
    Write-Host "=== PowerShell Tester Tool ===" -ForegroundColor Cyan
    Write-Host "1. Run All Tests"
    Write-Host "2. Run Specific Test"
    Write-Host "3. View Test Results"
    Write-Host "4. Generate HTML Report"
    Write-Host "5. Exit"
}

<#
.SYNOPSIS
Defines the test cases. Add your test functions here.
#>
function Define-Tests {
    $global:tests = @{
        "Test1" = { Test-Case1 }
        "Test2" = { Test-Case2 }
        "Test3" = { Test-Case3 }
        # Add more test cases as needed
    }
}

<#
.SYNOPSIS
Example test case 1. Replace with your actual test logic.
#>
function Test-Case1 {
    $testName = "Test Case 1"
    $description = "Description of Test Case 1"
    try {
        # Your test logic here
        $result = $true
        $message = "Test Case 1 passed successfully"
    }
    catch {
        $result = $false
        $message = "Test Case 1 failed: $_"
    }
    return [PSCustomObject]@{
        TestName = $testName
        Description = $description
        Result = $result
        Message = $message
    }
}

<#
.SYNOPSIS
Example test case 2. Replace with your actual test logic.
#>
function Test-Case2 {
    $testName = "Test Case 2"
    $description = "Description of Test Case 2"
    try {
        # Your test logic here
        $result = $true
        $message = "Test Case 2 passed successfully"
    }
    catch {
        $result = $false
        $message = "Test Case 2 failed: $_"
    }
    return [PSCustomObject]@{
        TestName = $testName
        Description = $description
        Result = $result
        Message = $message
    }
}

<#
.SYNOPSIS
Example test case 3. Replace with your actual test logic.
#>
function Test-Case3 {
    $testName = "Test Case 3"
    $description = "Description of Test Case 3"
    try {
        # Your test logic here
        $result = $true
        $message = "Test Case 3 passed successfully"
    }
    catch {
        $result = $false
        $message = "Test Case 3 failed: $_"
    }
    return [PSCustomObject]@{
        TestName = $testName
        Description = $description
        Result = $result
        Message = $message
    }
}

<#
.SYNOPSIS
Runs all defined tests.
#>
function Run-AllTests {
    Write-Host "`nRunning All Tests..." -ForegroundColor Yellow
    $global:testResults = @()
    foreach ($test in $global:tests.GetEnumerator()) {
        Write-Host "Running $($test.Key)..." -ForegroundColor Cyan
        $result = & $test.Value
        $global:testResults += $result
        if ($result.Result) {
            Write-Host "  Passed: $($result.Message)" -ForegroundColor Green
        } else {
            Write-Host "  Failed: $($result.Message)" -ForegroundColor Red
        }
    }
}

<#
.SYNOPSIS
Runs a specific test based on user input.
#>
function Run-SpecificTest {
    Write-Host "`nAvailable Tests:" -ForegroundColor Yellow
    $global:tests.Keys | ForEach-Object { Write-Host "  $_" }
    $testName = Read-Host "`nEnter the name of the test to run"
    if ($global:tests.ContainsKey($testName)) {
        Write-Host "Running $testName..." -ForegroundColor Cyan
        $result = & $global:tests[$testName]
        $global:testResults += $result
        if ($result.Result) {
            Write-Host "  Passed: $($result.Message)" -ForegroundColor Green
        } else {
            Write-Host "  Failed: $($result.Message)" -ForegroundColor Red
        }
    } else {
        Write-Host "Test not found." -ForegroundColor Red
    }
}

<#
.SYNOPSIS
Displays the results of all run tests.
#>
function View-TestResults {
    if ($global:testResults.Count -eq 0) {
        Write-Host "`nNo tests have been run yet." -ForegroundColor Yellow
    } else {
        Write-Host "`nTest Results:" -ForegroundColor Yellow
        $global:testResults | Format-Table -AutoSize
    }
}

<#
.SYNOPSIS
Generates an HTML report of the test results.
#>
function Generate-HTMLReport {
    Write-Host "`nGenerating HTML Report..." -ForegroundColor Yellow
    $reportContent = @"
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Test Results Report</title>
    <style>
        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; max-width: 800px; margin: 0 auto; padding: 20px; }
        h1 { color: #0078D4; }
        table { border-collapse: collapse; width: 100%; margin-top: 20px; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #f2f2f2; }
        .pass { color: green; }
        .fail { color: red; }
    </style>
</head>
<body>
    <h1>Test Results Report</h1>
    <p>Generated on: $(Get-Date)</p>
    <table>
        <tr>
            <th>Test Name</th>
            <th>Description</th>
            <th>Result</th>
            <th>Message</th>
        </tr>
        $(foreach ($result in $global:testResults) {
            $resultClass = if ($result.Result) { "pass" } else { "fail" }
            "<tr>
                <td>$($result.TestName)</td>
                <td>$($result.Description)</td>
                <td class='$resultClass'>$(if ($result.Result) { "Pass" } else { "Fail" })</td>
                <td>$($result.Message)</td>
            </tr>"
        })
    </table>
</body>
</html>
"@

    $reportContent | Out-File -FilePath $global:reportPath
    Write-Host "Report generated and saved to: $global:reportPath" -ForegroundColor Green
}

# Main program loop
Define-Tests
do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-5)"

    switch ($choice) {
        "1" { Run-AllTests }
        "2" { Run-SpecificTest }
        "3" { View-TestResults }
        "4" { Generate-HTMLReport }
        "5" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "5") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "5")

This PowerShell Tester Tool Template includes:

A menu-driven interface for easy navigation.
Functions for defining and running tests.
Placeholder test case functions that you can replace with your actual test logic.
Ability to run all tests or a specific test.
Function to view test results.
HTML report generation for test results.

Key features:

Flexible structure for defining multiple test cases
Easy-to-use menu for running tests and viewing results
Detailed test result tracking, including test name, description, result, and message
HTML report generation for easy sharing and documentation of test results
Modular design for easy expansion and modification

To use this template effectively:

Replace the placeholder test case functions (Test-Case1, Test-Case2, Test-Case3) with your specific test logic.
Add more test cases as needed in the Define-Tests function.
Customize the test result object properties if you need to capture additional information.
Modify the HTML report generation function if you want to change the report format or add more details.
Add any necessary module imports or additional global variables at the beginning of the script.

This template provides a solid foundation for creating various types of testing tools in PowerShell, whether you’re testing system configurations, application functionality, or any other scenario that requires structured testing and reporting.

Template Menu-Driven PowerShell Tool

10/08/2024/0 Comments/in Templates/by Laszlo Bocso

<#
.SYNOPSIS
Template Menu-Driven PowerShell Tool

.DESCRIPTION
This script provides a template for a menu-driven PowerShell tool that can be customized
for various administrative or analysis tasks.

.NOTES
File Name      : TemplateMenuTool.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\TemplateMenuTool.ps1
#>

# Global variables
$global:reportPath = "$env:USERPROFILE\Desktop\Analysis_Report_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"

<#
.SYNOPSIS
Displays the main menu of the tool.
#>
function Show-Menu {
    Clear-Host
    Write-Host "=== Template Menu-Driven Tool ===" -ForegroundColor Cyan
    Write-Host "1. Set Target (e.g., computer, path, etc.)"
    Write-Host "2. Perform Analysis Task 1"
    Write-Host "3. Perform Analysis Task 2"
    Write-Host "4. Perform Analysis Task 3"
    Write-Host "5. Perform Analysis Task 4"
    Write-Host "6. Perform Analysis Task 5"
    Write-Host "7. Generate Comprehensive HTML Report"
    Write-Host "8. Exit"
}

<#
.SYNOPSIS
Sets the target for analysis (e.g., computer name, file path, etc.).
#>
function Set-Target {
    $target = Read-Host "Enter the target for analysis (e.g., computer name, file path)"
    if (-not [string]::IsNullOrWhiteSpace($target)) {
        $global:target = $target
        Write-Host "Target set to: $global:target" -ForegroundColor Green
    } else {
        Write-Host "Invalid target. Please try again." -ForegroundColor Red
    }
}

<#
.SYNOPSIS
Performs Analysis Task 1.

.OUTPUTS
Array of PSObjects containing analysis results.
#>
function Perform-AnalysisTask1 {
    Write-Host "`nPerforming Analysis Task 1..." -ForegroundColor Yellow
    # Add your analysis logic here
    $results = @([PSCustomObject]@{
        Property1 = "Value1"
        Property2 = "Value2"
    })
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Performs Analysis Task 2.

.OUTPUTS
Array of PSObjects containing analysis results.
#>
function Perform-AnalysisTask2 {
    Write-Host "`nPerforming Analysis Task 2..." -ForegroundColor Yellow
    # Add your analysis logic here
    $results = @([PSCustomObject]@{
        Property1 = "Value1"
        Property2 = "Value2"
    })
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Performs Analysis Task 3.

.OUTPUTS
Array of PSObjects containing analysis results.
#>
function Perform-AnalysisTask3 {
    Write-Host "`nPerforming Analysis Task 3..." -ForegroundColor Yellow
    # Add your analysis logic here
    $results = @([PSCustomObject]@{
        Property1 = "Value1"
        Property2 = "Value2"
    })
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Performs Analysis Task 4.

.OUTPUTS
Array of PSObjects containing analysis results.
#>
function Perform-AnalysisTask4 {
    Write-Host "`nPerforming Analysis Task 4..." -ForegroundColor Yellow
    # Add your analysis logic here
    $results = @([PSCustomObject]@{
        Property1 = "Value1"
        Property2 = "Value2"
    })
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Performs Analysis Task 5.

.OUTPUTS
Array of PSObjects containing analysis results.
#>
function Perform-AnalysisTask5 {
    Write-Host "`nPerforming Analysis Task 5..." -ForegroundColor Yellow
    # Add your analysis logic here
    $results = @([PSCustomObject]@{
        Property1 = "Value1"
        Property2 = "Value2"
    })
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Generates a comprehensive HTML report of all analyses.

.PARAMETER AllResults
Hashtable containing all analysis results.

.OUTPUTS
Saves an HTML report to the desktop.
#>
function Generate-HTMLReport {
    param([hashtable]$AllResults)

    Write-Host "`nGenerating Comprehensive HTML Report..." -ForegroundColor Yellow
    $reportContent = @"
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Analysis Report</title>
    <style>
        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; max-width: 1200px; margin: 0 auto; padding: 20px; }
        h1, h2, h3 { color: #0078D4; }
        table { border-collapse: collapse; width: 100%; margin-bottom: 20px; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #f2f2f2; }
    </style>
</head>
<body>
    <h1>Analysis Report</h1>
    <p>Generated on: $(Get-Date)</p>
    <p>Target: $global:target</p>

    <h2>Analysis Task 1 Results</h2>
    $($AllResults.Task1Results | ConvertTo-Html -Fragment)

    <h2>Analysis Task 2 Results</h2>
    $($AllResults.Task2Results | ConvertTo-Html -Fragment)

    <h2>Analysis Task 3 Results</h2>
    $($AllResults.Task3Results | ConvertTo-Html -Fragment)

    <h2>Analysis Task 4 Results</h2>
    $($AllResults.Task4Results | ConvertTo-Html -Fragment)

    <h2>Analysis Task 5 Results</h2>
    $($AllResults.Task5Results | ConvertTo-Html -Fragment)
</body>
</html>
"@

    $reportContent | Out-File -FilePath $global:reportPath
    Write-Host "Report generated and saved to: $global:reportPath" -ForegroundColor Green
}

# Main program loop
$allResults = @{}

do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-8)"

    switch ($choice) {
        "1" { Set-Target }
        "2" { $allResults.Task1Results = Perform-AnalysisTask1 }
        "3" { $allResults.Task2Results = Perform-AnalysisTask2 }
        "4" { $allResults.Task3Results = Perform-AnalysisTask3 }
        "5" { $allResults.Task4Results = Perform-AnalysisTask4 }
        "6" { $allResults.Task5Results = Perform-AnalysisTask5 }
        "7" { Generate-HTMLReport -AllResults $allResults }
        "8" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "8") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "8")

This Template Menu-Driven Tool includes:

A menu-driven interface for easy navigation.
Placeholder functions for five different analysis tasks.
A function to set a target for analysis (which can be customized based on your needs).
A function to generate an HTML report of all collected data.
Basic error handling and user input validation.

Key features:

Easy-to-customize menu structure
Placeholder functions for various analysis tasks
Ability to set and use a global target variable
HTML report generation capability
Modular design for easy expansion and modification

To use this template effectively:

Replace the placeholder analysis functions (Perform-AnalysisTask1, Perform-AnalysisTask2, etc.) with your specific analysis logic.
Customize the Set-Target function to handle the type of target you need (e.g., computer name, file path, etc.).
Modify the menu options and corresponding switch statement in the main program loop to match your specific tasks.
Adjust the HTML report generation function to include the specific results you want to display.
Add any necessary module imports or additional global variables at the beginning of the script.

This template provides a solid foundation for creating various types of menu-driven PowerShell tools for system administration, security analysis, or any other task that requires user interaction and multiple analysis steps.

Certificates Analyzer Tool

10/08/2024/0 Comments/in Program/by Laszlo Bocso

<#
.SYNOPSIS
Certificates Analyzer Tool

.DESCRIPTION
This script analyzes and audits certificates on a Windows system, including those in the
certificate store and those used by IIS. It provides insights into certificate expiration,
usage, and potential issues.

.NOTES
File Name      : CertificatesAnalyzer.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later, administrator rights, and IIS if analyzing IIS certificates
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\CertificatesAnalyzer.ps1
#>

# Import required modules
Import-Module WebAdministration -ErrorAction SilentlyContinue

# Global variables
$global:reportPath = "$env:USERPROFILE\Desktop\Certificates_Analysis_Report_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"

<#
.SYNOPSIS
Displays the main menu of the tool.
#>
function Show-Menu {
    Clear-Host
    Write-Host "=== Certificates Analyzer Tool ===" -ForegroundColor Cyan
    Write-Host "1. Analyze All Certificates in Local Machine Store"
    Write-Host "2. Check for Expiring Certificates"
    Write-Host "3. Analyze IIS Binding Certificates"
    Write-Host "4. Check for Weak Key Certificates"
    Write-Host "5. Analyze Certificate Chain"
    Write-Host "6. Check for Duplicate Certificates"
    Write-Host "7. Analyze Certificate Usage"
    Write-Host "8. Generate Comprehensive HTML Report"
    Write-Host "9. Exit"
}

<#
.SYNOPSIS
Analyzes all certificates in the Local Machine store.

.OUTPUTS
Array of PSObjects containing certificate details.
#>
function Analyze-AllCertificates {
    Write-Host "`nAnalyzing All Certificates in Local Machine Store..." -ForegroundColor Yellow
    $certs = Get-ChildItem -Path Cert:\LocalMachine -Recurse | Where-Object { $_.PSIsContainer -eq $false }
    $results = @()
    foreach ($cert in $certs) {
        $results += [PSCustomObject]@{
            Subject = $cert.Subject
            Issuer = $cert.Issuer
            Thumbprint = $cert.Thumbprint
            NotBefore = $cert.NotBefore
            NotAfter = $cert.NotAfter
            Store = $cert.PSParentPath.Split('\')[-1]
            HasPrivateKey = $cert.HasPrivateKey
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Checks for expiring certificates.

.OUTPUTS
Array of PSObjects containing expiring certificate details.
#>
function Check-ExpiringCertificates {
    Write-Host "`nChecking for Expiring Certificates..." -ForegroundColor Yellow
    $expirationThreshold = (Get-Date).AddDays(30)
    $certs = Get-ChildItem -Path Cert:\LocalMachine -Recurse | Where-Object { $_.PSIsContainer -eq $false -and $_.NotAfter -le $expirationThreshold }
    $results = @()
    foreach ($cert in $certs) {
        $results += [PSCustomObject]@{
            Subject = $cert.Subject
            Thumbprint = $cert.Thumbprint
            ExpirationDate = $cert.NotAfter
            DaysUntilExpiration = ($cert.NotAfter - (Get-Date)).Days
            Store = $cert.PSParentPath.Split('\')[-1]
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Analyzes IIS binding certificates.

.OUTPUTS
Array of PSObjects containing IIS binding certificate details.
#>
function Analyze-IISBindingCertificates {
    Write-Host "`nAnalyzing IIS Binding Certificates..." -ForegroundColor Yellow
    $results = @()
    if (Get-Module -ListAvailable -Name WebAdministration) {
        $websites = Get-Website
        foreach ($site in $websites) {
            $bindings = $site.Bindings.Collection | Where-Object { $_.Protocol -eq "https" }
            foreach ($binding in $bindings) {
                $cert = Get-ChildItem -Path Cert:\LocalMachine\My | Where-Object { $_.Thumbprint -eq $binding.CertificateHash }
                if ($cert) {
                    $results += [PSCustomObject]@{
                        Website = $site.Name
                        Binding = $binding.BindingInformation
                        CertSubject = $cert.Subject
                        Thumbprint = $cert.Thumbprint
                        ExpirationDate = $cert.NotAfter
                        DaysUntilExpiration = ($cert.NotAfter - (Get-Date)).Days
                    }
                }
            }
        }
    } else {
        Write-Host "WebAdministration module not available. Unable to analyze IIS bindings." -ForegroundColor Red
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Checks for certificates with weak keys.

.OUTPUTS
Array of PSObjects containing weak key certificate details.
#>
function Check-WeakKeyCertificates {
    Write-Host "`nChecking for Weak Key Certificates..." -ForegroundColor Yellow
    $certs = Get-ChildItem -Path Cert:\LocalMachine -Recurse | Where-Object { $_.PSIsContainer -eq $false }
    $results = @()
    foreach ($cert in $certs) {
        if ($cert.PublicKey.Key.KeySize -lt 2048) {
            $results += [PSCustomObject]@{
                Subject = $cert.Subject
                Thumbprint = $cert.Thumbprint
                KeySize = $cert.PublicKey.Key.KeySize
                Store = $cert.PSParentPath.Split('\')[-1]
            }
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Analyzes certificate chains.

.OUTPUTS
Array of PSObjects containing certificate chain details.
#>
function Analyze-CertificateChain {
    Write-Host "`nAnalyzing Certificate Chain..." -ForegroundColor Yellow
    $certs = Get-ChildItem -Path Cert:\LocalMachine -Recurse | Where-Object { $_.PSIsContainer -eq $false }
    $results = @()
    foreach ($cert in $certs) {
        $chain = New-Object -TypeName System.Security.Cryptography.X509Certificates.X509Chain
        $chain.Build($cert) | Out-Null
        $chainStatus = $chain.ChainStatus | ForEach-Object { $_.Status }
        $results += [PSCustomObject]@{
            Subject = $cert.Subject
            Thumbprint = $cert.Thumbprint
            ChainValid = $chain.ChainStatus.Length -eq 0
            ChainStatus = if ($chainStatus) { $chainStatus -join ", " } else { "Valid" }
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Checks for duplicate certificates.

.OUTPUTS
Array of PSObjects containing duplicate certificate details.
#>
function Check-DuplicateCertificates {
    Write-Host "`nChecking for Duplicate Certificates..." -ForegroundColor Yellow
    $certs = Get-ChildItem -Path Cert:\LocalMachine -Recurse | Where-Object { $_.PSIsContainer -eq $false }
    $duplicates = $certs | Group-Object -Property Thumbprint | Where-Object { $_.Count -gt 1 }
    $results = @()
    foreach ($duplicate in $duplicates) {
        foreach ($cert in $duplicate.Group) {
            $results += [PSCustomObject]@{
                Subject = $cert.Subject
                Thumbprint = $cert.Thumbprint
                Store = $cert.PSParentPath.Split('\')[-1]
                NotAfter = $cert.NotAfter
            }
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Analyzes certificate usage.

.OUTPUTS
Array of PSObjects containing certificate usage details.
#>
function Analyze-CertificateUsage {
    Write-Host "`nAnalyzing Certificate Usage..." -ForegroundColor Yellow
    $certs = Get-ChildItem -Path Cert:\LocalMachine -Recurse | Where-Object { $_.PSIsContainer -eq $false }
    $results = @()
    foreach ($cert in $certs) {
        $enhancedKeyUsage = $cert.EnhancedKeyUsageList | ForEach-Object { $_.FriendlyName }
        $results += [PSCustomObject]@{
            Subject = $cert.Subject
            Thumbprint = $cert.Thumbprint
            KeyUsage = $cert.KeyUsages -join ", "
            EnhancedKeyUsage = if ($enhancedKeyUsage) { $enhancedKeyUsage -join ", " } else { "Not specified" }
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Generates a comprehensive HTML report of all analyses.

.PARAMETER AllResults
Hashtable containing all analysis results.

.OUTPUTS
Saves an HTML report to the desktop.
#>
function Generate-HTMLReport {
    param([hashtable]$AllResults)

    Write-Host "`nGenerating Comprehensive HTML Report..." -ForegroundColor Yellow
    $reportContent = @"
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Certificates Analysis Report</title>
    <style>
        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; max-width: 1200px; margin: 0 auto; padding: 20px; }
        h1, h2, h3 { color: #0078D4; }
        table { border-collapse: collapse; width: 100%; margin-bottom: 20px; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #f2f2f2; }
    </style>
</head>
<body>
    <h1>Certificates Analysis Report</h1>
    <p>Generated on: $(Get-Date)</p>

    <h2>All Certificates</h2>
    $($AllResults.AllCertificates | ConvertTo-Html -Fragment)

    <h2>Expiring Certificates</h2>
    $($AllResults.ExpiringCertificates | ConvertTo-Html -Fragment)

    <h2>IIS Binding Certificates</h2>
    $($AllResults.IISBindingCertificates | ConvertTo-Html -Fragment)

    <h2>Weak Key Certificates</h2>
    $($AllResults.WeakKeyCertificates | ConvertTo-Html -Fragment)

    <h2>Certificate Chain Analysis</h2>
    $($AllResults.CertificateChain | ConvertTo-Html -Fragment)

    <h2>Duplicate Certificates</h2>
    $($AllResults.DuplicateCertificates | ConvertTo-Html -Fragment)

    <h2>Certificate Usage</h2>
    $($AllResults.CertificateUsage | ConvertTo-Html -Fragment)
</body>
</html>
"@

    $reportContent | Out-File -FilePath $global:reportPath
    Write-Host "Report generated and saved to: $global:reportPath" -ForegroundColor Green
}

# Main program loop
$allResults = @{}

do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-9)"

    switch ($choice) {
        "1" { $allResults.AllCertificates = Analyze-AllCertificates }
        "2" { $allResults.ExpiringCertificates = Check-ExpiringCertificates }
        "3" { $allResults.IISBindingCertificates = Analyze-IISBindingCertificates }
        "4" { $allResults.WeakKeyCertificates = Check-WeakKeyCertificates }
        "5" { $allResults.CertificateChain = Analyze-CertificateChain }
        "6" { $allResults.DuplicateCertificates = Check-DuplicateCertificates }
        "7" { $allResults.CertificateUsage = Analyze-CertificateUsage }
        "8" { Generate-HTMLReport -AllResults $allResults }
        "9" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "9") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "9")

This Certificates Analyzer Tool includes:

A menu-driven interface for easy navigation.
Functions to analyze various aspects of certificates:
- Analysis of all certificates in the Local Machine store
- Check for expiring certificates
- Analysis of IIS binding certificates
- Check for weak key certificates
- Analysis of certificate chains
- Check for duplicate certificates
- Analysis of certificate usage
Comprehensive error handling for each analysis function.
A function to generate an HTML report of all collected data.

Key features:

Detailed analysis of all certificates in the Local Machine store
Identification of certificates nearing expiration
Review of certificates used in IIS bindings
Detection of certificates with weak keys
Analysis of certificate chains for validity
Identification of duplicate certificates across stores
Examination of certificate usage and purposes
Comprehensive HTML report generation

This tool is particularly useful for:

System administrators managing certificates
Security professionals auditing certificate deployments
IT professionals troubleshooting certificate-related issues
DevOps engineers managing SSL/TLS certificates

To use this script effectively:

Run PowerShell as an administrator
Ensure you have the necessary permissions to access certificate stores
Have the WebAdministration module available if you want to analyze IIS certificates

This script provides a comprehensive overview of certificates on a Windows system, making it easier to audit and maintain certificate deployments, identify potential issues, and ensure the security of SSL/TLS implementations.

IIS (Internet Information Services) Analyzer Tool

09/08/2024/0 Comments/in Program/by Laszlo Bocso

<#
.SYNOPSIS
IIS (Internet Information Services) Analyzer Tool

.DESCRIPTION
This script analyzes and audits IIS configurations, including websites, application pools,
bindings, SSL certificates, and other related settings on Windows Servers.

.NOTES
File Name      : IISAnalyzer.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later, WebAdministration module, and appropriate permissions
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\IISAnalyzer.ps1
#>

# Check if WebAdministration module is available
if (-not (Get-Module -ListAvailable -Name WebAdministration)) {
    Write-Host "WebAdministration module not found. Please ensure IIS is installed with management tools." -ForegroundColor Red
    exit
}

# Import required module
Import-Module WebAdministration

# Global variables
$global:reportPath = "$env:USERPROFILE\Desktop\IIS_Analysis_Report_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"

<#
.SYNOPSIS
Displays the main menu of the tool.
#>
function Show-Menu {
    Clear-Host
    Write-Host "=== IIS Analyzer Tool ===" -ForegroundColor Cyan
    Write-Host "1. Analyze Websites"
    Write-Host "2. Review Application Pools"
    Write-Host "3. Analyze Bindings and SSL Certificates"
    Write-Host "4. Check Virtual Directories"
    Write-Host "5. Review HTTP Response Headers"
    Write-Host "6. Analyze Authentication Settings"
    Write-Host "7. Check Logging Configuration"
    Write-Host "8. Generate Comprehensive HTML Report"
    Write-Host "9. Exit"
}

<#
.SYNOPSIS
Analyzes IIS Websites.

.OUTPUTS
Array of PSObjects containing Website details.
#>
function Analyze-Websites {
    Write-Host "`nAnalyzing Websites..." -ForegroundColor Yellow
    $websites = Get-Website
    $results = @()
    foreach ($site in $websites) {
        $results += [PSCustomObject]@{
            Name = $site.Name
            ID = $site.ID
            State = $site.State
            PhysicalPath = $site.PhysicalPath
            ApplicationPool = $site.ApplicationPool
            Bindings = ($site.Bindings.Collection | ForEach-Object { "$($_.Protocol)/$($_.BindingInformation)" }) -join ", "
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Reviews Application Pools.

.OUTPUTS
Array of PSObjects containing Application Pool details.
#>
function Review-ApplicationPools {
    Write-Host "`nReviewing Application Pools..." -ForegroundColor Yellow
    $appPools = Get-IISAppPool
    $results = @()
    foreach ($pool in $appPools) {
        $results += [PSCustomObject]@{
            Name = $pool.Name
            State = $pool.State
            ManagedRuntimeVersion = $pool.ManagedRuntimeVersion
            ManagedPipelineMode = $pool.ManagedPipelineMode
            StartMode = $pool.StartMode
            IdentityType = $pool.ProcessModel.IdentityType
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Analyzes Bindings and SSL Certificates.

.OUTPUTS
Array of PSObjects containing Binding and SSL Certificate details.
#>
function Analyze-BindingsAndSSL {
    Write-Host "`nAnalyzing Bindings and SSL Certificates..." -ForegroundColor Yellow
    $websites = Get-Website
    $results = @()
    foreach ($site in $websites) {
        foreach ($binding in $site.Bindings.Collection) {
            $cert = $null
            if ($binding.Protocol -eq "https") {
                $cert = Get-ChildItem -Path "Cert:\LocalMachine\My" | Where-Object {$_.Thumbprint -eq $binding.CertificateHash}
            }
            $results += [PSCustomObject]@{
                Website = $site.Name
                Protocol = $binding.Protocol
                BindingInfo = $binding.BindingInformation
                SSLThumbprint = if ($cert) { $cert.Thumbprint } else { "N/A" }
                SSLExpirationDate = if ($cert) { $cert.NotAfter } else { "N/A" }
            }
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Checks Virtual Directories.

.OUTPUTS
Array of PSObjects containing Virtual Directory details.
#>
function Check-VirtualDirectories {
    Write-Host "`nChecking Virtual Directories..." -ForegroundColor Yellow
    $vdirs = Get-WebVirtualDirectory
    $results = @()
    foreach ($vdir in $vdirs) {
        $results += [PSCustomObject]@{
            Name = $vdir.Name
            PhysicalPath = $vdir.PhysicalPath
            Application = $vdir.Application
            Website = $vdir.Website
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Reviews HTTP Response Headers.

.OUTPUTS
Array of PSObjects containing HTTP Response Header details.
#>
function Review-HTTPResponseHeaders {
    Write-Host "`nReviewing HTTP Response Headers..." -ForegroundColor Yellow
    $websites = Get-Website
    $results = @()
    foreach ($site in $websites) {
        $headers = Get-WebConfigurationProperty -Filter "system.webServer/httpProtocol/customHeaders" -PSPath "IIS:\Sites\$($site.Name)" -Name "."
        foreach ($header in $headers.Collection) {
            $results += [PSCustomObject]@{
                Website = $site.Name
                HeaderName = $header.Name
                HeaderValue = $header.Value
            }
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Analyzes Authentication Settings.

.OUTPUTS
Array of PSObjects containing Authentication Setting details.
#>
function Analyze-AuthenticationSettings {
    Write-Host "`nAnalyzing Authentication Settings..." -ForegroundColor Yellow
    $websites = Get-Website
    $results = @()
    foreach ($site in $websites) {
        $authTypes = @("Anonymous", "Basic", "Windows", "Digest")
        $authSettings = @{}
        foreach ($authType in $authTypes) {
            $authSettings[$authType] = (Get-WebConfigurationProperty -Filter "system.webServer/security/authentication/$authType`Authentication" -PSPath "IIS:\Sites\$($site.Name)" -Name "enabled").Value
        }
        $results += [PSCustomObject]@{
            Website = $site.Name
            AnonymousAuth = $authSettings["Anonymous"]
            BasicAuth = $authSettings["Basic"]
            WindowsAuth = $authSettings["Windows"]
            DigestAuth = $authSettings["Digest"]
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Checks Logging Configuration.

.OUTPUTS
Array of PSObjects containing Logging Configuration details.
#>
function Check-LoggingConfiguration {
    Write-Host "`nChecking Logging Configuration..." -ForegroundColor Yellow
    $websites = Get-Website
    $results = @()
    foreach ($site in $websites) {
        $logFile = Get-WebConfigurationProperty -Filter "system.applicationHost/sites/site[@name='$($site.Name)']/logFile" -PSPath "MACHINE/WEBROOT/APPHOST" -Name "."
        $results += [PSCustomObject]@{
            Website = $site.Name
            LogFormat = $logFile.logFormat
            Directory = $logFile.directory
            Enabled = $logFile.enabled
            Period = $logFile.period
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Generates a comprehensive HTML report of all analyses.

.PARAMETER AllResults
Hashtable containing all analysis results.

.OUTPUTS
Saves an HTML report to the desktop.
#>
function Generate-HTMLReport {
    param([hashtable]$AllResults)

    Write-Host "`nGenerating Comprehensive HTML Report..." -ForegroundColor Yellow
    $reportContent = @"
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>IIS Analysis Report</title>
    <style>
        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; max-width: 1200px; margin: 0 auto; padding: 20px; }
        h1, h2, h3 { color: #0078D4; }
        table { border-collapse: collapse; width: 100%; margin-bottom: 20px; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #f2f2f2; }
    </style>
</head>
<body>
    <h1>IIS Analysis Report</h1>
    <p>Generated on: $(Get-Date)</p>

    <h2>Websites</h2>
    $($AllResults.Websites | ConvertTo-Html -Fragment)

    <h2>Application Pools</h2>
    $($AllResults.ApplicationPools | ConvertTo-Html -Fragment)

    <h2>Bindings and SSL Certificates</h2>
    $($AllResults.BindingsAndSSL | ConvertTo-Html -Fragment)

    <h2>Virtual Directories</h2>
    $($AllResults.VirtualDirectories | ConvertTo-Html -Fragment)

    <h2>HTTP Response Headers</h2>
    $($AllResults.HTTPResponseHeaders | ConvertTo-Html -Fragment)

    <h2>Authentication Settings</h2>
    $($AllResults.AuthenticationSettings | ConvertTo-Html -Fragment)

    <h2>Logging Configuration</h2>
    $($AllResults.LoggingConfiguration | ConvertTo-Html -Fragment)
</body>
</html>
"@

    $reportContent | Out-File -FilePath $global:reportPath
    Write-Host "Report generated and saved to: $global:reportPath" -ForegroundColor Green
}

# Main program loop
$allResults = @{}

do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-9)"

    switch ($choice) {
        "1" { $allResults.Websites = Analyze-Websites }
        "2" { $allResults.ApplicationPools = Review-ApplicationPools }
        "3" { $allResults.BindingsAndSSL = Analyze-BindingsAndSSL }
        "4" { $allResults.VirtualDirectories = Check-VirtualDirectories }
        "5" { $allResults.HTTPResponseHeaders = Review-HTTPResponseHeaders }
        "6" { $allResults.AuthenticationSettings = Analyze-AuthenticationSettings }
        "7" { $allResults.LoggingConfiguration = Check-LoggingConfiguration }
        "8" { Generate-HTMLReport -AllResults $allResults }
        "9" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "9") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "9")

This IIS Analyzer Tool includes:

A menu-driven interface for easy navigation.
Functions to analyze various aspects of IIS:
- Website analysis
- Application Pool review
- Bindings and SSL Certificate analysis
- Virtual Directory check
- HTTP Response Header review
- Authentication Settings analysis
- Logging Configuration check
Comprehensive error handling for each analysis function.
A function to generate an HTML report of all collected data.

Key features:

Detailed analysis of IIS Websites and their configurations
Review of Application Pools and their settings
Analysis of Bindings and SSL Certificates, including expiration dates
Examination of Virtual Directories
Overview of custom HTTP Response Headers
Analysis of Authentication Settings for each website
Review of Logging Configurations
Comprehensive HTML report generation

This tool is particularly useful for:

IIS Administrators managing web servers
System administrators overseeing IIS configurations
Security professionals auditing web server settings
DevOps engineers managing IIS deployments

To use this script effectively:

Run PowerShell as an administrator
Ensure IIS is installed with the management tools (which includes the WebAdministration module)
Have the necessary permissions to query IIS configurations

This script provides a comprehensive overview of IIS configurations on a Windows Server, making it easier to audit and maintain IIS settings, websites, and application pools. It can significantly streamline the process of managing and documenting IIS configurations in enterprise environments.

File Server Resource Manager (FSRM) Analyzer Tool

09/08/2024/0 Comments/in Program/by Laszlo Bocso

<#
.SYNOPSIS
File Server Resource Manager (FSRM) Analyzer Tool

.DESCRIPTION
This script analyzes and audits File Server Resource Manager configurations, including
quotas, file screens, file groups, and classification rules on Windows Servers.

.NOTES
File Name      : FSRMAnalyzer.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later, FSRM feature installed, and appropriate permissions
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\FSRMAnalyzer.ps1
#>

# Check if FSRM module is available
if (-not (Get-Module -ListAvailable -Name FileServerResourceManager)) {
    Write-Host "File Server Resource Manager module not found. Please ensure FSRM is installed." -ForegroundColor Red
    exit
}

# Import required module
Import-Module FileServerResourceManager

# Global variables
$global:reportPath = "$env:USERPROFILE\Desktop\FSRM_Analysis_Report_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"

<#
.SYNOPSIS
Displays the main menu of the tool.
#>
function Show-Menu {
    Clear-Host
    Write-Host "=== File Server Resource Manager Analyzer Tool ===" -ForegroundColor Cyan
    Write-Host "1. Analyze Quota Templates"
    Write-Host "2. Review File Screen Templates"
    Write-Host "3. Analyze File Groups"
    Write-Host "4. Review Classification Rules"
    Write-Host "5. Check File Management Tasks"
    Write-Host "6. Analyze Storage Reports"
    Write-Host "7. Review FSRM Settings"
    Write-Host "8. Generate Comprehensive HTML Report"
    Write-Host "9. Exit"
}

<#
.SYNOPSIS
Analyzes Quota Templates.

.OUTPUTS
Array of PSObjects containing Quota Template details.
#>
function Analyze-QuotaTemplates {
    Write-Host "`nAnalyzing Quota Templates..." -ForegroundColor Yellow
    $quotaTemplates = Get-FsrmQuotaTemplate
    $results = @()
    foreach ($template in $quotaTemplates) {
        $results += [PSCustomObject]@{
            Name = $template.Name
            Size = $template.Size
            SoftLimit = $template.SoftLimit
            ThresholdPercentages = $template.Threshold -join ", "
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Reviews File Screen Templates.

.OUTPUTS
Array of PSObjects containing File Screen Template details.
#>
function Review-FileScreenTemplates {
    Write-Host "`nReviewing File Screen Templates..." -ForegroundColor Yellow
    $screenTemplates = Get-FsrmFileScreenTemplate
    $results = @()
    foreach ($template in $screenTemplates) {
        $results += [PSCustomObject]@{
            Name = $template.Name
            IncludeGroup = $template.IncludeGroup -join ", "
            Active = $template.Active
            Description = $template.Description
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Analyzes File Groups.

.OUTPUTS
Array of PSObjects containing File Group details.
#>
function Analyze-FileGroups {
    Write-Host "`nAnalyzing File Groups..." -ForegroundColor Yellow
    $fileGroups = Get-FsrmFileGroup
    $results = @()
    foreach ($group in $fileGroups) {
        $results += [PSCustomObject]@{
            Name = $group.Name
            IncludePattern = $group.IncludePattern -join ", "
            ExcludePattern = $group.ExcludePattern -join ", "
            Description = $group.Description
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Reviews Classification Rules.

.OUTPUTS
Array of PSObjects containing Classification Rule details.
#>
function Review-ClassificationRules {
    Write-Host "`nReviewing Classification Rules..." -ForegroundColor Yellow
    $classRules = Get-FsrmClassificationRule
    $results = @()
    foreach ($rule in $classRules) {
        $results += [PSCustomObject]@{
            Name = $rule.Name
            Property = $rule.Property
            PropertyValue = $rule.PropertyValue
            Description = $rule.Description
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Checks File Management Tasks.

.OUTPUTS
Array of PSObjects containing File Management Task details.
#>
function Check-FileManagementTasks {
    Write-Host "`nChecking File Management Tasks..." -ForegroundColor Yellow
    $fmTasks = Get-FsrmFileManagementJob
    $results = @()
    foreach ($task in $fmTasks) {
        $results += [PSCustomObject]@{
            Name = $task.Name
            Namespace = $task.Namespace
            Action = $task.Action
            Enabled = $task.Enabled
            Schedule = $task.Schedule
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Analyzes Storage Reports.

.OUTPUTS
Array of PSObjects containing Storage Report details.
#>
function Analyze-StorageReports {
    Write-Host "`nAnalyzing Storage Reports..." -ForegroundColor Yellow
    $reports = Get-FsrmStorageReport
    $results = @()
    foreach ($report in $reports) {
        $results += [PSCustomObject]@{
            Name = $report.Name
            NameSpace = $report.NameSpace
            ReportFormats = $report.ReportFormats -join ", "
            Schedule = $report.Schedule
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Reviews FSRM Settings.

.OUTPUTS
PSObject containing FSRM Settings.
#>
function Review-FSRMSettings {
    Write-Host "`nReviewing FSRM Settings..." -ForegroundColor Yellow
    $settings = Get-FsrmSetting
    $results = [PSCustomObject]@{
        SmtpServer = $settings.SmtpServer
        AdminEmailAddress = $settings.AdminEmailAddress
        FromEmailAddress = $settings.FromEmailAddress
        CommandNotificationLimit = $settings.CommandNotificationLimit
        EmailNotificationLimit = $settings.EmailNotificationLimit
        EventNotificationLimit = $settings.EventNotificationLimit
    }
    $results | Format-List
    return $results
}

<#
.SYNOPSIS
Generates a comprehensive HTML report of all analyses.

.PARAMETER AllResults
Hashtable containing all analysis results.

.OUTPUTS
Saves an HTML report to the desktop.
#>
function Generate-HTMLReport {
    param([hashtable]$AllResults)

    Write-Host "`nGenerating Comprehensive HTML Report..." -ForegroundColor Yellow
    $reportContent = @"
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>FSRM Analysis Report</title>
    <style>
        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; max-width: 1200px; margin: 0 auto; padding: 20px; }
        h1, h2, h3 { color: #0078D4; }
        table { border-collapse: collapse; width: 100%; margin-bottom: 20px; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #f2f2f2; }
    </style>
</head>
<body>
    <h1>File Server Resource Manager Analysis Report</h1>
    <p>Generated on: $(Get-Date)</p>

    <h2>Quota Templates</h2>
    $($AllResults.QuotaTemplates | ConvertTo-Html -Fragment)

    <h2>File Screen Templates</h2>
    $($AllResults.FileScreenTemplates | ConvertTo-Html -Fragment)

    <h2>File Groups</h2>
    $($AllResults.FileGroups | ConvertTo-Html -Fragment)

    <h2>Classification Rules</h2>
    $($AllResults.ClassificationRules | ConvertTo-Html -Fragment)

    <h2>File Management Tasks</h2>
    $($AllResults.FileManagementTasks | ConvertTo-Html -Fragment)

    <h2>Storage Reports</h2>
    $($AllResults.StorageReports | ConvertTo-Html -Fragment)

    <h2>FSRM Settings</h2>
    $($AllResults.FSRMSettings | ConvertTo-Html -Fragment)
</body>
</html>
"@

    $reportContent | Out-File -FilePath $global:reportPath
    Write-Host "Report generated and saved to: $global:reportPath" -ForegroundColor Green
}

# Main program loop
$allResults = @{}

do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-9)"

    switch ($choice) {
        "1" { $allResults.QuotaTemplates = Analyze-QuotaTemplates }
        "2" { $allResults.FileScreenTemplates = Review-FileScreenTemplates }
        "3" { $allResults.FileGroups = Analyze-FileGroups }
        "4" { $allResults.ClassificationRules = Review-ClassificationRules }
        "5" { $allResults.FileManagementTasks = Check-FileManagementTasks }
        "6" { $allResults.StorageReports = Analyze-StorageReports }
        "7" { $allResults.FSRMSettings = Review-FSRMSettings }
        "8" { Generate-HTMLReport -AllResults $allResults }
        "9" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "9") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "9")

This File Server Resource Manager (FSRM) Analyzer Tool includes:

A menu-driven interface for easy navigation.
Functions to analyze various aspects of FSRM:
- Quota Templates analysis
- File Screen Templates review
- File Groups analysis
- Classification Rules review
- File Management Tasks check
- Storage Reports analysis
- FSRM Settings review
Comprehensive error handling for each analysis function.
A function to generate an HTML report of all collected data.

Key features:

Detailed analysis of Quota Templates and their thresholds
Review of File Screen Templates and their included file groups
Analysis of File Groups and their patterns
Examination of Classification Rules
Overview of File Management Tasks and their schedules
Analysis of configured Storage Reports
Review of general FSRM settings like email configurations
Comprehensive HTML report generation

This tool is particularly useful for:

System administrators managing file servers
Storage administrators overseeing quota and file screening policies
IT auditors reviewing file server configurations
Compliance officers ensuring adherence to file management policies

To use this script effectively:

Run PowerShell as an administrator
Ensure the File Server Resource Manager feature is installed on the server
Have the necessary permissions to query FSRM configurations

This script provides a comprehensive overview of File Server Resource Manager configurations on a Windows Server, making it easier to audit and maintain FSRM policies, quotas, and file screening rules. It can significantly streamline the process of managing and documenting FSRM configurations in enterprise environments.

Group Policy Analyzer Tool

09/08/2024/0 Comments/in Program/by Laszlo Bocso

<#
.SYNOPSIS
Group Policy Analyzer Tool

.DESCRIPTION
This script analyzes and audits Group Policy Objects (GPOs) in an Active Directory environment,
providing detailed information about policy settings, links, and potential issues.

.NOTES
File Name      : GroupPolicyAnalyzer.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later, GroupPolicy module, and appropriate AD permissions
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\GroupPolicyAnalyzer.ps1
#>

# Import required modules
Import-Module GroupPolicy
Import-Module ActiveDirectory

# Global variables
$global:reportPath = "$env:USERPROFILE\Desktop\GPO_Analysis_Report_$(Get-Date -Format 'yyyyMMdd_HHmmss').html"

<#
.SYNOPSIS
Displays the main menu of the tool.
#>
function Show-Menu {
    Clear-Host
    Write-Host "=== Group Policy Analyzer Tool ===" -ForegroundColor Cyan
    Write-Host "1. Analyze All GPOs"
    Write-Host "2. Find Unlinked GPOs"
    Write-Host "3. Identify GPOs with No Settings"
    Write-Host "4. Check for Conflicting GPO Settings"
    Write-Host "5. Analyze GPO Links"
    Write-Host "6. Review GPO Permissions"
    Write-Host "7. Check GPO Version Numbers"
    Write-Host "8. Analyze GPO WMI Filters"
    Write-Host "9. Generate Comprehensive HTML Report"
    Write-Host "10. Exit"
}

<#
.SYNOPSIS
Analyzes all GPOs in the domain.

.OUTPUTS
Array of PSObjects containing GPO details.
#>
function Analyze-AllGPOs {
    Write-Host "`nAnalyzing All GPOs..." -ForegroundColor Yellow
    $gpos = Get-GPO -All
    $results = @()
    foreach ($gpo in $gpos) {
        $report = Get-GPOReport -Guid $gpo.Id -ReportType XML
        $settingsCount = ([xml]$report).GPO.Computer.ExtensionData.Extension.Policy.Count + 
                         ([xml]$report).GPO.User.ExtensionData.Extension.Policy.Count
        $results += [PSCustomObject]@{
            Name = $gpo.DisplayName
            ID = $gpo.Id
            CreationTime = $gpo.CreationTime
            ModificationTime = $gpo.ModificationTime
            SettingsCount = $settingsCount
            Status = $gpo.GpoStatus
        }
    }
    $results | Format-Table -AutoSize
    return $results
}

<#
.SYNOPSIS
Finds unlinked GPOs in the domain.

.OUTPUTS
Array of PSObjects containing unlinked GPO details.
#>
function Find-UnlinkedGPOs {
    Write-Host "`nFinding Unlinked GPOs..." -ForegroundColor Yellow
    $gpos = Get-GPO -All
    $unlinkedGPOs = @()
    foreach ($gpo in $gpos) {
        $linkedOUs = Get-ADOrganizationalUnit -Filter * | Where-Object {(Get-GPInheritance -Target $_.DistinguishedName).GpoLinks.DisplayName -contains $gpo.DisplayName}
        if ($linkedOUs.Count -eq 0) {
            $unlinkedGPOs += [PSCustomObject]@{
                Name = $gpo.DisplayName
                ID = $gpo.Id
                CreationTime = $gpo.CreationTime
            }
        }
    }
    $unlinkedGPOs | Format-Table -AutoSize
    return $unlinkedGPOs
}

<#
.SYNOPSIS
Identifies GPOs with no settings configured.

.OUTPUTS
Array of PSObjects containing empty GPO details.
#>
function Identify-EmptyGPOs {
    Write-Host "`nIdentifying GPOs with No Settings..." -ForegroundColor Yellow
    $gpos = Get-GPO -All
    $emptyGPOs = @()
    foreach ($gpo in $gpos) {
        $report = Get-GPOReport -Guid $gpo.Id -ReportType XML
        $settingsCount = ([xml]$report).GPO.Computer.ExtensionData.Extension.Policy.Count + 
                         ([xml]$report).GPO.User.ExtensionData.Extension.Policy.Count
        if ($settingsCount -eq 0) {
            $emptyGPOs += [PSCustomObject]@{
                Name = $gpo.DisplayName
                ID = $gpo.Id
                CreationTime = $gpo.CreationTime
            }
        }
    }
    $emptyGPOs | Format-Table -AutoSize
    return $emptyGPOs
}

<#
.SYNOPSIS
Checks for potentially conflicting GPO settings.

.OUTPUTS
Array of PSObjects containing conflicting GPO details.
#>
function Check-ConflictingGPOSettings {
    Write-Host "`nChecking for Conflicting GPO Settings..." -ForegroundColor Yellow
    $gpos = Get-GPO -All
    $conflictingSettings = @()
    $allSettings = @{}

    foreach ($gpo in $gpos) {
        $report = ([xml](Get-GPOReport -Guid $gpo.Id -ReportType XML))
        $settings = $report.GPO.Computer.ExtensionData.Extension.Policy + $report.GPO.User.ExtensionData.Extension.Policy
        
        foreach ($setting in $settings) {
            $key = "$($setting.Name):$($setting.Class)"
            if ($allSettings.ContainsKey($key)) {
                $conflictingSettings += [PSCustomObject]@{
                    SettingName = $setting.Name
                    GPO1 = $allSettings[$key]
                    GPO2 = $gpo.DisplayName
                }
            } else {
                $allSettings[$key] = $gpo.DisplayName
            }
        }
    }
    $conflictingSettings | Format-Table -AutoSize
    return $conflictingSettings
}

<#
.SYNOPSIS
Analyzes GPO links across the domain.

.OUTPUTS
Array of PSObjects containing GPO link details.
#>
function Analyze-GPOLinks {
    Write-Host "`nAnalyzing GPO Links..." -ForegroundColor Yellow
    $domain = Get-ADDomain
    $ous = Get-ADOrganizationalUnit -Filter *
    $gpoLinks = @()

    foreach ($ou in $ous) {
        $links = (Get-GPInheritance -Target $ou.DistinguishedName).GpoLinks
        foreach ($link in $links) {
            $gpoLinks += [PSCustomObject]@{
                GPOName = $link.DisplayName
                LinkedOU = $ou.Name
                Enabled = $link.Enabled
                Enforced = $link.Enforced
                Order = $link.Order
            }
        }
    }
    $gpoLinks | Format-Table -AutoSize
    return $gpoLinks
}

<#
.SYNOPSIS
Reviews GPO permissions.

.OUTPUTS
Array of PSObjects containing GPO permission details.
#>
function Review-GPOPermissions {
    Write-Host "`nReviewing GPO Permissions..." -ForegroundColor Yellow
    $gpos = Get-GPO -All
    $gpoPermissions = @()

    foreach ($gpo in $gpos) {
        $permissions = Get-GPPermission -Guid $gpo.Id -All
        foreach ($perm in $permissions) {
            $gpoPermissions += [PSCustomObject]@{
                GPOName = $gpo.DisplayName
                Trustee = $perm.Trustee.Name
                Permission = $perm.Permission
            }
        }
    }
    $gpoPermissions | Format-Table -AutoSize
    return $gpoPermissions
}

<#
.SYNOPSIS
Checks GPO version numbers.

.OUTPUTS
Array of PSObjects containing GPO version details.
#>
function Check-GPOVersions {
    Write-Host "`nChecking GPO Version Numbers..." -ForegroundColor Yellow
    $gpos = Get-GPO -All
    $gpoVersions = @()

    foreach ($gpo in $gpos) {
        $gpoVersions += [PSCustomObject]@{
            Name = $gpo.DisplayName
            ComputerVersion = $gpo.Computer.DSVersion
            UserVersion = $gpo.User.DSVersion
        }
    }
    $gpoVersions | Format-Table -AutoSize
    return $gpoVersions
}

<#
.SYNOPSIS
Analyzes GPO WMI Filters.

.OUTPUTS
Array of PSObjects containing GPO WMI Filter details.
#>
function Analyze-GPOWMIFilters {
    Write-Host "`nAnalyzing GPO WMI Filters..." -ForegroundColor Yellow
    $gpos = Get-GPO -All
    $wmiFilters = @()

    foreach ($gpo in $gpos) {
        $filter = $gpo.WmiFilter
        if ($filter) {
            $wmiFilters += [PSCustomObject]@{
                GPOName = $gpo.DisplayName
                WMIFilterName = $filter.Name
                WMIFilterDescription = $filter.Description
            }
        }
    }
    $wmiFilters | Format-Table -AutoSize
    return $wmiFilters
}

<#
.SYNOPSIS
Generates a comprehensive HTML report of all analyses.

.PARAMETER AllResults
Hashtable containing all analysis results.

.OUTPUTS
Saves an HTML report to the desktop.
#>
function Generate-HTMLReport {
    param([hashtable]$AllResults)

    Write-Host "`nGenerating Comprehensive HTML Report..." -ForegroundColor Yellow
    $reportContent = @"
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Group Policy Analysis Report</title>
    <style>
        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; max-width: 1200px; margin: 0 auto; padding: 20px; }
        h1, h2, h3 { color: #0078D4; }
        table { border-collapse: collapse; width: 100%; margin-bottom: 20px; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #f2f2f2; }
    </style>
</head>
<body>
    <h1>Group Policy Analysis Report</h1>
    <p>Generated on: $(Get-Date)</p>

    <h2>All GPOs</h2>
    $($AllResults.AllGPOs | ConvertTo-Html -Fragment)

    <h2>Unlinked GPOs</h2>
    $($AllResults.UnlinkedGPOs | ConvertTo-Html -Fragment)

    <h2>Empty GPOs</h2>
    $($AllResults.EmptyGPOs | ConvertTo-Html -Fragment)

    <h2>Conflicting GPO Settings</h2>
    $($AllResults.ConflictingSettings | ConvertTo-Html -Fragment)

    <h2>GPO Links</h2>
    $($AllResults.GPOLinks | ConvertTo-Html -Fragment)

    <h2>GPO Permissions</h2>
    $($AllResults.GPOPermissions | ConvertTo-Html -Fragment)

    <h2>GPO Versions</h2>
    $($AllResults.GPOVersions | ConvertTo-Html -Fragment)

    <h2>GPO WMI Filters</h2>
    $($AllResults.WMIFilters | ConvertTo-Html -Fragment)
</body>
</html>
"@

    $reportContent | Out-File -FilePath $global:reportPath
    Write-Host "Report generated and saved to: $global:reportPath" -ForegroundColor Green
}

# Main program loop
$allResults = @{}

do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-10)"

    switch ($choice) {
        "1" { $allResults.AllGPOs = Analyze-AllGPOs }
        "2" { $allResults.UnlinkedGPOs = Find-UnlinkedGPOs }
        "3" { $allResults.EmptyGPOs = Identify-EmptyGPOs }
        "4" { $allResults.ConflictingSettings = Check-ConflictingGPOSettings }
        "5" { $allResults.GPOLinks = Analyze-GPOLinks }
        "6" { $allResults.GPOPermissions = Review-GPOPermissions }
        "7" { $allResults.GPOVersions = Check-GPOVersions }
        "8" { $allResults.WMIFilters = Analyze-GPOWMIFilters }
        "9" { Generate-HTMLReport -AllResults $allResults }
        "10" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "10") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "10")

This Group Policy Analyzer Tool includes:

A menu-driven interface for easy navigation.
Functions to analyze various aspects of Group Policy:
- Analysis of all GPOs
- Identification of unlinked GPOs
- Detection of GPOs with no settings
- Checking for conflicting GPO settings
- Analysis of GPO links
- Review of GPO permissions
- Checking GPO version numbers
- Analysis of GPO WMI filters
Comprehensive error handling for each analysis function.
A function to generate an HTML report of all collected data.

Key features:

Detailed analysis of all GPOs in the domain
Identification of potential issues like unlinked or empty GPOs
Detection of conflicting policy settings
Review of GPO links and their order
Analysis of GPO permissions for security auditing
Version number checks to identify potential replication issues
WMI filter analysis
Comprehensive HTML report generation

This tool is particularly useful for:

Active Directory administrators managing complex GPO environments
IT auditors reviewing Group Policy configurations
System administrators troubleshooting Group Policy issues
Security professionals assessing GPO-based security settings

To use this script effectively:

Run PowerShell as an administrator
Ensure you have the necessary permissions to query GPOs in your domain
Have the GroupPolicy and ActiveDirectory PowerShell modules installed

This script provides a comprehensive overview of Group Policy configurations in an Active Directory environment, making it easier to identify issues, inconsistencies, or security concerns related to GPOs. It can significantly streamline the process of auditing and maintaining Group Policies in large or complex AD environments.

Latest News

PowerShell Tester Tool Template

Template Menu-Driven PowerShell Tool

Certificates Analyzer Tool

IIS (Internet Information Services) Analyzer Tool

File Server Resource Manager (FSRM) Analyzer Tool

Windows PowerShell

Links

Contact

Sitemap