powershellblog.com – Page 17 – 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!

Azure Active Directory Monitoring Tool

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

# Expert Azure Active Directory Monitoring Tool

# Ensure the required modules are installed
# Install-Module -Name AzureAD, MSOnline, AzureADPreview -Force

# Import required modules
Import-Module AzureAD
Import-Module MSOnline
Import-Module AzureADPreview

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

function Show-Menu {
    Clear-Host
    Write-Host "=== Expert Azure AD Monitoring Tool ===" -ForegroundColor Cyan
    Write-Host "1.  Tenant Overview"
    Write-Host "2.  User Account Analysis"
    Write-Host "3.  Group Management Audit"
    Write-Host "4.  Application Integration Assessment"
    Write-Host "5.  Conditional Access Policies Review"
    Write-Host "6.  Security Configuration Analysis"
    Write-Host "7.  Identity Protection Status"
    Write-Host "8.  Device Management Overview"
    Write-Host "9.  Privileged Identity Management Audit"
    Write-Host "10. Azure AD Connect Health Status"
    Write-Host "11. License Usage and Assignment"
    Write-Host "12. Generate Comprehensive HTML Report"
    Write-Host "13. Exit"
}

function Connect-AzureServices {
    try {
        Connect-AzureAD
        Connect-MsolService
        Write-Host "Successfully connected to Azure services." -ForegroundColor Green
    }
    catch {
        Write-Host "Failed to connect to Azure services. Please check your credentials and try again." -ForegroundColor Red
        Exit
    }
}

function Get-TenantOverview {
    Write-Host "`nRetrieving Tenant Overview..." -ForegroundColor Yellow
    $tenantInfo = Get-AzureADTenantDetail
    $domainInfo = Get-AzureADDomain
    $verifiedDomains = ($domainInfo | Where-Object { $_.IsVerified -eq $true }).Count
    $unverifiedDomains = ($domainInfo | Where-Object { $_.IsVerified -eq $false }).Count

    $overview = [PSCustomObject]@{
        TenantName = $tenantInfo.DisplayName
        TenantId = $tenantInfo.ObjectId
        VerifiedDomains = $verifiedDomains
        UnverifiedDomains = $unverifiedDomains
        TechnicalContacts = $tenantInfo.TechnicalNotificationMails -join ", "
    }

    $overview | Format-List
    return $overview
}

function Analyze-UserAccounts {
    Write-Host "`nAnalyzing User Accounts..." -ForegroundColor Yellow
    $users = Get-AzureADUser -All $true
    $guestUsers = $users | Where-Object { $_.UserType -eq 'Guest' }
    $mfaUsers = Get-MsolUser -All | Where-Object { $_.StrongAuthenticationRequirements.State -ne $null }

    $analysis = [PSCustomObject]@{
        TotalUsers = $users.Count
        EnabledUsers = ($users | Where-Object { $_.AccountEnabled -eq $true }).Count
        DisabledUsers = ($users | Where-Object { $_.AccountEnabled -eq $false }).Count
        GuestUsers = $guestUsers.Count
        MFAEnabledUsers = $mfaUsers.Count
        RecentlyCreatedUsers = ($users | Where-Object { $_.CreatedDateTime -gt (Get-Date).AddDays(-30) }).Count
    }

    $analysis | Format-List
    return $analysis
}

function Audit-GroupManagement {
    Write-Host "`nAuditing Group Management..." -ForegroundColor Yellow
    $groups = Get-AzureADGroup -All $true
    $dynamicGroups = $groups | Where-Object { $_.GroupTypes -contains "DynamicMembership" }

    $audit = [PSCustomObject]@{
        TotalGroups = $groups.Count
        SecurityGroups = ($groups | Where-Object { $_.SecurityEnabled -eq $true }).Count
        DistributionGroups = ($groups | Where-Object { $_.SecurityEnabled -eq $false }).Count
        DynamicGroups = $dynamicGroups.Count
        EmptyGroups = ($groups | Where-Object { (Get-AzureADGroupMember -ObjectId $_.ObjectId).Count -eq 0 }).Count
    }

    $audit | Format-List
    return $audit
}

function Assess-ApplicationIntegration {
    Write-Host "`nAssessing Application Integration..." -ForegroundColor Yellow
    $apps = Get-AzureADApplication -All $true
    $enterpriseApps = Get-AzureADServicePrincipal -All $true

    $assessment = [PSCustomObject]@{
        TotalApps = $apps.Count
        EnterpriseApps = $enterpriseApps.Count
        AppsWithSecrets = ($apps | Where-Object { $_.PasswordCredentials.Count -gt 0 -or $_.KeyCredentials.Count -gt 0 }).Count
        RecentlyAddedApps = ($apps | Where-Object { $_.CreatedDateTime -gt (Get-Date).AddDays(-30) }).Count
    }

    $assessment | Format-List
    return $assessment
}

function Review-ConditionalAccessPolicies {
    Write-Host "`nReviewing Conditional Access Policies..." -ForegroundColor Yellow
    $policies = Get-AzureADMSConditionalAccessPolicy

    $review = [PSCustomObject]@{
        TotalPolicies = $policies.Count
        EnabledPolicies = ($policies | Where-Object { $_.State -eq "enabled" }).Count
        DisabledPolicies = ($policies | Where-Object { $_.State -eq "disabled" }).Count
        ReportOnlyPolicies = ($policies | Where-Object { $_.State -eq "enabledForReportingButNotEnforced" }).Count
    }

    $review | Format-List
    return $review
}

function Analyze-SecurityConfiguration {
    Write-Host "`nAnalyzing Security Configuration..." -ForegroundColor Yellow
    $securityDefaults = (Get-MsolCompanyInformation).SecurityDefaultsEnabled
    $passwordPolicy = Get-MsolPasswordPolicy -TenantId (Get-MsolCompanyInformation).ObjectId

    $analysis = [PSCustomObject]@{
        SecurityDefaultsEnabled = $securityDefaults
        PasswordValidityPeriod = $passwordPolicy.ValidityPeriod
        MinimumPasswordLength = $passwordPolicy.MinimumPasswordLength
        PasswordComplexityEnabled = $passwordPolicy.StrongPasswordRequired
    }

    $analysis | Format-List
    return $analysis
}

function Get-IdentityProtectionStatus {
    Write-Host "`nRetrieving Identity Protection Status..." -ForegroundColor Yellow
    $riskDetections = Get-AzureADIdentityProtectionRiskDetection -Top 1000
    $riskyUsers = Get-AzureADIdentityProtectionRiskyUser -Top 1000

    $status = [PSCustomObject]@{
        TotalRiskDetections = $riskDetections.Count
        HighRiskDetections = ($riskDetections | Where-Object { $_.RiskLevel -eq "High" }).Count
        RiskyUsers = $riskyUsers.Count
        HighRiskUsers = ($riskyUsers | Where-Object { $_.RiskLevel -eq "High" }).Count
    }

    $status | Format-List
    return $status
}

function Get-DeviceManagementOverview {
    Write-Host "`nRetrieving Device Management Overview..." -ForegroundColor Yellow
    $devices = Get-AzureADDevice -All $true

    $overview = [PSCustomObject]@{
        TotalDevices = $devices.Count
        EnabledDevices = ($devices | Where-Object { $_.AccountEnabled -eq $true }).Count
        DisabledDevices = ($devices | Where-Object { $_.AccountEnabled -eq $false }).Count
        ManagedDevices = ($devices | Where-Object { $_.IsManaged -eq $true }).Count
        CompliantDevices = ($devices | Where-Object { $_.IsCompliant -eq $true }).Count
    }

    $overview | Format-List
    return $overview
}

function Audit-PrivilegedIdentityManagement {
    Write-Host "`nAuditing Privileged Identity Management..." -ForegroundColor Yellow
    $pimRoles = Get-AzureADMSPrivilegedRoleDefinition

    $audit = [PSCustomObject]@{
        TotalPIMRoles = $pimRoles.Count
        ActiveAssignments = (Get-AzureADMSPrivilegedRoleAssignment -ProviderId "aadRoles" -ResourceId (Get-AzureADTenantDetail).ObjectId | Where-Object { $_.AssignmentState -eq "Active" }).Count
        EligibleAssignments = (Get-AzureADMSPrivilegedRoleAssignment -ProviderId "aadRoles" -ResourceId (Get-AzureADTenantDetail).ObjectId | Where-Object { $_.AssignmentState -eq "Eligible" }).Count
    }

    $audit | Format-List
    return $audit
}

function Get-AzureADConnectHealthStatus {
    Write-Host "`nRetrieving Azure AD Connect Health Status..." -ForegroundColor Yellow
    $adConnectStatus = Get-MsolCompanyInformation | Select-Object -Property DirectorySynchronizationEnabled, DirectorySynchronizationStatus, LastDirSyncTime, LastPasswordSyncTime

    $status = [PSCustomObject]@{
        SyncEnabled = $adConnectStatus.DirectorySynchronizationEnabled
        SyncStatus = $adConnectStatus.DirectorySynchronizationStatus
        LastSyncTime = $adConnectStatus.LastDirSyncTime
        LastPasswordSyncTime = $adConnectStatus.LastPasswordSyncTime
    }

    $status | Format-List
    return $status
}

function Analyze-LicenseUsage {
    Write-Host "`nAnalyzing License Usage and Assignment..." -ForegroundColor Yellow
    $licenses = Get-MsolAccountSku

    $analysis = @()
    foreach ($license in $licenses) {
        $analysis += [PSCustomObject]@{
            SkuPartNumber = $license.SkuPartNumber
            TotalUnits = $license.ActiveUnits
            UsedUnits = $license.ConsumedUnits
            AvailableUnits = $license.ActiveUnits - $license.ConsumedUnits
        }
    }

    $analysis | Format-Table -AutoSize
    return $analysis
}

function Generate-HTMLReport {
    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>Azure AD Expert Report</title>
    <style>
        body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; max-width: 800px; margin: 0 auto; padding: 20px; }
        h1, h2 { 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>Azure AD Expert Report</h1>
    <p>Generated on: $(Get-Date)</p>

    <h2>Tenant Overview</h2>
    $($overview | ConvertTo-Html -Fragment)

    <h2>User Account Analysis</h2>
    $($analysis | ConvertTo-Html -Fragment)

    <h2>Group Management Audit</h2>
    $($audit | ConvertTo-Html -Fragment)

    <h2>Application Integration Assessment</h2>
    $($assessment | ConvertTo-Html -Fragment)

    <h2>Conditional Access Policies Review</h2>
    $($review | ConvertTo-Html -Fragment)

    <h2>Security Configuration Analysis</h2>
    $($securityAnalysis | ConvertTo-Html -Fragment)

    <h2>Identity Protection Status</h2>
    $($identityProtectionStatus | ConvertTo-Html -Fragment)

    <h2>Device Management Overview</h2>
    $($deviceOverview | ConvertTo-Html -Fragment)

    <h2>Privileged Identity Management Audit</h2>
    $($pimAudit | ConvertTo-Html -Fragment)

    <h2>Azure AD Connect Health Status</h2>
    $($adConnectStatus | ConvertTo-Html -Fragment)

    <h2>License Usage and Assignment</h2>
    $($licenseAnalysis | ConvertTo-Html -Fragment)
</body>
</html>
"@

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

# Main program
Connect-AzureServices

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

    switch ($choice) {
        "1"  { $overview = Get-TenantOverview }
        "2"  { $analysis = Analyze-UserAccounts }
        "3"  { $audit = Audit-GroupManagement }
        "4"  { $assessment = Assess-ApplicationIntegration }
        "5"  { $review = Review-ConditionalAccessPolicies }
        "6"  { $securityAnalysis = Analyze-SecurityConfiguration }
        "7"  { $identityProtectionStatus = Get-IdentityProtectionStatus }
        "8"  { $deviceOverview = Get-DeviceManagementOverview }
        "9"  { $pimAudit = Audit-PrivilegedIdentityManagement }
        "10" { $adConnectStatus = Get-AzureADConnectHealthStatus }
        "11" { $licenseAnalysis = Analyze-LicenseUsage }
        "12" { Generate-HTMLReport }
        "13" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

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

This Azure AD Monitoring Tool includes:

A comprehensive menu with 13 options
Advanced functions for various Azure AD monitoring and analysis tasks:
- Tenant overview
- User account analysis
- Group management audit
- Application integration assessment
- Conditional Access policies review
- Security configuration analysis
- Identity Protection status
- Device management overview
- Privileged Identity Management audit
- Azure AD Connect health status
- License usage and assignment analysis
Use of multiple Azure AD PowerShell modules (AzureAD, MSOnline, AzureADPreview)
Detailed output and reporting capabilities, including HTML report generation

Key features:

Comprehensive Tenant Overview: Provides key information about the Azure AD tenant
In-depth User Analysis: Analyzes user accounts, including guest users and MFA status
Group Management Audit: Examines group types and configurations
Application Integration Assessment: Reviews registered applications and service principals
Conditional Access Review: Summarizes Conditional Access policies
Security Configuration Analysis: Checks security defaults and password policies
Identity Protection Insights: Provides an overview of risk detections and risky users
Device Management Overview: Summarizes device registration and compliance status
PIM Audit: Reviews Privileged Identity Management roles and assignments
Azure AD Connect Health Check: Verifies directory synchronization status
License Analysis: Examines license allocation and usage

This tool provides a comprehensive analysis of an Azure AD environment. It’s particularly useful for:

Conducting regular Azure AD health checks
Preparing for security audits
Identifying potential security risks
Optimizing license usage
Generating detailed reports for management or compliance purposes

Note: To use this script effectively, you need to:

Run PowerShell as an administrator
Have the necessary Azure AD PowerShell modules installed
Have appropriate permissions in the Azure AD environment (Global Administrator or similar high-level role)
Be prepared to authenticate to Azure AD when prompted

This script is suitable for experienced Azure AD administrators who need comprehensive monitoring and analysis capabilities for managing complex Azure AD environments.

Advanced Active Directory Monitoring Tool

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

# Advanced Active Directory Monitoring Tool

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

function Show-Menu {
    Clear-Host
    Write-Host "=== Advanced Active Directory Monitoring Tool ===" -ForegroundColor Cyan
    Write-Host "1.  Check Domain Controllers Health"
    Write-Host "2.  Analyze User Accounts"
    Write-Host "3.  Monitor Group Policy Changes"
    Write-Host "4.  Audit Active Directory Replication"
    Write-Host "5.  Check DNS Health"
    Write-Host "6.  Monitor FSMO Roles"
    Write-Host "7.  Analyze Active Directory Structure"
    Write-Host "8.  Check Trust Relationships"
    Write-Host "9.  Monitor Active Directory Services"
    Write-Host "10. Generate Comprehensive Report"
    Write-Host "11. Exit"
}

function Check-DomainControllersHealth {
    Write-Host "`nChecking Domain Controllers Health..." -ForegroundColor Yellow
    $dcs = Get-ADDomainController -Filter *
    $results = @()
    foreach ($dc in $dcs) {
        $status = Test-Connection -ComputerName $dc.HostName -Count 1 -Quiet
        $dcdiag = Invoke-Command -ComputerName $dc.HostName -ScriptBlock { dcdiag /test:services /test:advertising /test:fsmocheck } -ErrorAction SilentlyContinue
        $results += [PSCustomObject]@{
            Name = $dc.HostName
            Online = if ($status) { "Yes" } else { "No" }
            Services = if ($dcdiag -match "passed test Services") { "Passed" } else { "Failed" }
            Advertising = if ($dcdiag -match "passed test Advertising") { "Passed" } else { "Failed" }
            FSMORoles = if ($dcdiag -match "passed test FsmoCheck") { "Passed" } else { "Failed" }
        }
    }
    $results | Format-Table -AutoSize
}

function Analyze-UserAccounts {
    Write-Host "`nAnalyzing User Accounts..." -ForegroundColor Yellow
    $inactiveThreshold = (Get-Date).AddDays(-90)
    $users = Get-ADUser -Filter * -Properties LastLogonDate, PasswordLastSet, PasswordNeverExpires, Enabled
    $userAnalysis = @{
        TotalUsers = $users.Count
        ActiveUsers = ($users | Where-Object { $_.Enabled -eq $true }).Count
        InactiveUsers = ($users | Where-Object { $_.LastLogonDate -lt $inactiveThreshold }).Count
        PasswordNeverExpires = ($users | Where-Object { $_.PasswordNeverExpires -eq $true }).Count
        RecentlyCreated = ($users | Where-Object { $_.Created -gt (Get-Date).AddDays(-30) }).Count
    }
    $userAnalysis | Format-Table -AutoSize
}

function Monitor-GroupPolicyChanges {
    Write-Host "`nMonitoring Group Policy Changes..." -ForegroundColor Yellow
    $domain = Get-ADDomain
    $gpos = Get-GPO -All -Domain $domain.DNSRoot
    $recentChanges = $gpos | Where-Object { $_.ModificationTime -gt (Get-Date).AddDays(-7) }
    $recentChanges | Select-Object DisplayName, ModificationTime, Owner | Format-Table -AutoSize
}

function Audit-ADReplication {
    Write-Host "`nAuditing Active Directory Replication..." -ForegroundColor Yellow
    $results = repadmin /showrepl * /csv | ConvertFrom-Csv
    $failedReplications = $results | Where-Object { $_."Number of Failures" -ne "0" }
    if ($failedReplications) {
        $failedReplications | Select-Object "Source DC", "Destination DC", "Number of Failures", "Last Failure Time" | Format-Table -AutoSize
    } else {
        Write-Host "No replication failures detected." -ForegroundColor Green
    }
}

function Check-DNSHealth {
    Write-Host "`nChecking DNS Health..." -ForegroundColor Yellow
    $dnsServers = Get-ADDomainController -Filter * | Select-Object -ExpandProperty HostName
    foreach ($server in $dnsServers) {
        $result = Invoke-Command -ComputerName $server -ScriptBlock { dnscmd /info }
        if ($result -match "DNS Server is running") {
            Write-Host "$server: DNS Service is running" -ForegroundColor Green
        } else {
            Write-Host "$server: DNS Service is not running" -ForegroundColor Red
        }
    }
}

function Monitor-FSMORoles {
    Write-Host "`nMonitoring FSMO Roles..." -ForegroundColor Yellow
    $roles = Get-ADDomain | Select-Object PDCEmulator, RIDMaster, InfrastructureMaster
    $roles | Add-Member -MemberType NoteProperty -Name "SchemaMaster" -Value (Get-ADForest).SchemaMaster
    $roles | Add-Member -MemberType NoteProperty -Name "DomainNamingMaster" -Value (Get-ADForest).DomainNamingMaster
    $roles | Format-List
}

function Analyze-ADStructure {
    Write-Host "`nAnalyzing Active Directory Structure..." -ForegroundColor Yellow
    $domainInfo = Get-ADDomain
    $forestInfo = Get-ADForest
    Write-Host "Domain: $($domainInfo.DNSRoot)"
    Write-Host "Forest: $($forestInfo.Name)"
    Write-Host "Domain Controllers: $((Get-ADDomainController -Filter *).Count)"
    Write-Host "OUs: $((Get-ADOrganizationalUnit -Filter *).Count)"
    Write-Host "Groups: $((Get-ADGroup -Filter *).Count)"
    Write-Host "Users: $((Get-ADUser -Filter *).Count)"
    Write-Host "Computers: $((Get-ADComputer -Filter *).Count)"
}

function Check-TrustRelationships {
    Write-Host "`nChecking Trust Relationships..." -ForegroundColor Yellow
    $trusts = Get-ADTrust -Filter *
    foreach ($trust in $trusts) {
        $status = Test-ComputerSecureChannel -Server $trust.Name
        Write-Host "Trust with $($trust.Name): $(if ($status) { 'Healthy' } else { 'Unhealthy' })"
    }
}

function Monitor-ADServices {
    Write-Host "`nMonitoring Active Directory Services..." -ForegroundColor Yellow
    $dcs = Get-ADDomainController -Filter *
    foreach ($dc in $dcs) {
        $services = Invoke-Command -ComputerName $dc.HostName -ScriptBlock {
            Get-Service -Name "NTDS", "DNS", "Netlogon", "KDC" | Select-Object Name, Status
        }
        Write-Host "Services on $($dc.HostName):"
        $services | Format-Table -AutoSize
    }
}

function Generate-ComprehensiveReport {
    Write-Host "`nGenerating Comprehensive Report..." -ForegroundColor Yellow
    $report = @"
===== Active Directory Comprehensive Report =====
Generated on: $(Get-Date)

"@
    $report += "`n--- Domain Controllers Health ---`n"
    $dcs = Get-ADDomainController -Filter *
    foreach ($dc in $dcs) {
        $status = Test-Connection -ComputerName $dc.HostName -Count 1 -Quiet
        $report += "$($dc.HostName): $(if ($status) { 'Online' } else { 'Offline' })`n"
    }

    $report += "`n--- User Account Summary ---`n"
    $users = Get-ADUser -Filter * -Properties LastLogonDate, PasswordLastSet, PasswordNeverExpires, Enabled
    $report += "Total Users: $($users.Count)`n"
    $report += "Active Users: $(($users | Where-Object { $_.Enabled -eq $true }).Count)`n"
    $report += "Inactive Users (90+ days): $(($users | Where-Object { $_.LastLogonDate -lt (Get-Date).AddDays(-90) }).Count)`n"

    $report += "`n--- Recent Group Policy Changes (Last 7 Days) ---`n"
    $gpos = Get-GPO -All
    $recentChanges = $gpos | Where-Object { $_.ModificationTime -gt (Get-Date).AddDays(-7) }
    foreach ($gpo in $recentChanges) {
        $report += "$($gpo.DisplayName) - Modified: $($gpo.ModificationTime)`n"
    }

    $report += "`n--- FSMO Roles ---`n"
    $roles = Get-ADDomain | Select-Object PDCEmulator, RIDMaster, InfrastructureMaster
    $roles | Add-Member -MemberType NoteProperty -Name "SchemaMaster" -Value (Get-ADForest).SchemaMaster
    $roles | Add-Member -MemberType NoteProperty -Name "DomainNamingMaster" -Value (Get-ADForest).DomainNamingMaster
    $report += $roles | Out-String

    $report += "`n--- Trust Relationships ---`n"
    $trusts = Get-ADTrust -Filter *
    foreach ($trust in $trusts) {
        $status = Test-ComputerSecureChannel -Server $trust.Name
        $report += "Trust with $($trust.Name): $(if ($status) { 'Healthy' } else { 'Unhealthy' })`n"
    }

    $reportPath = "$env:USERPROFILE\Desktop\AD_Report_$(Get-Date -Format 'yyyyMMdd_HHmmss').txt"
    $report | Out-File -FilePath $reportPath
    Write-Host "Report generated and saved to: $reportPath" -ForegroundColor Green
}

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

    switch ($choice) {
        "1"  { Check-DomainControllersHealth }
        "2"  { Analyze-UserAccounts }
        "3"  { Monitor-GroupPolicyChanges }
        "4"  { Audit-ADReplication }
        "5"  { Check-DNSHealth }
        "6"  { Monitor-FSMORoles }
        "7"  { Analyze-ADStructure }
        "8"  { Check-TrustRelationships }
        "9"  { Monitor-ADServices }
        "10" { Generate-ComprehensiveReport }
        "11" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

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

This Advanced Active Directory Monitoring Tool includes:

A comprehensive menu with 11 options
Advanced functions for various AD monitoring and analysis tasks:
- Detailed Domain Controller health check
- User account analysis
- Group Policy change monitoring
- AD replication auditing
- DNS health check
- FSMO roles monitoring
- AD structure analysis
- Trust relationship verification
- AD services monitoring
- Comprehensive report generation
Use of advanced Active Directory PowerShell cmdlets and system tools
Detailed output and reporting capabilities

Key features:

Comprehensive DC Health Check: Includes service status and DCDIAG tests
User Account Analysis: Provides statistics on active, inactive, and recently created accounts
Group Policy Monitoring: Tracks recent changes to Group Policies
Replication Audit: Checks for replication failures across the domain
DNS Health: Verifies DNS service status on all DCs
FSMO Roles: Displays the current holders of all FSMO roles
AD Structure Analysis: Gives an overview of the AD structure including counts of OUs, groups, users, and computers
Trust Relationships: Checks the health of trust relationships
Service Monitoring: Checks critical AD services across all DCs
Comprehensive Report: Generates a detailed report covering multiple aspects of AD health

This tool provides an in-depth analysis of an Active Directory environment. It’s particularly useful for:

Proactive monitoring of AD health
Troubleshooting complex AD issues
Regular AD maintenance and health checks
Generating reports for audits or management review

Note: To use this script effectively, you need to:

Run PowerShell as an administrator
Have the Active Directory and Group Policy PowerShell modules installed
Have appropriate permissions in the AD environment (Domain Admin or equivalent)
Some functions may require running on a Domain Controller

This script is suitable for experienced AD administrators who need comprehensive monitoring and analysis capabilities for managing complex Active Directory environments.

Simple Active Directory Monitoring Tool

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

# Simple Active Directory Monitoring Tool

# Import the Active Directory module
Import-Module ActiveDirectory

function Show-Menu {
    Clear-Host
    Write-Host "=== Simple Active Directory Monitoring Tool ===" -ForegroundColor Cyan
    Write-Host "1. Check Domain Controllers Status"
    Write-Host "2. List Recently Created Users"
    Write-Host "3. List Disabled User Accounts"
    Write-Host "4. Check Password Expiration"
    Write-Host "5. View Group Membership"
    Write-Host "6. Exit"
}

function Check-DomainControllers {
    Write-Host "`nChecking Domain Controllers Status..." -ForegroundColor Yellow
    $dcs = Get-ADDomainController -Filter *
    foreach ($dc in $dcs) {
        $status = Test-Connection -ComputerName $dc.HostName -Count 1 -Quiet
        if ($status) {
            Write-Host "$($dc.HostName) is Online" -ForegroundColor Green
        } else {
            Write-Host "$($dc.HostName) is Offline" -ForegroundColor Red
        }
    }
}

function List-RecentUsers {
    $days = Read-Host "Enter the number of days to check for new users"
    $date = (Get-Date).AddDays(-$days)
    Write-Host "`nListing users created in the last $days days..." -ForegroundColor Yellow
    Get-ADUser -Filter {Created -ge $date} -Properties Created | 
        Select-Object Name, SamAccountName, Created | 
        Format-Table -AutoSize
}

function List-DisabledUsers {
    Write-Host "`nListing disabled user accounts..." -ForegroundColor Yellow
    Get-ADUser -Filter {Enabled -eq $false} | 
        Select-Object Name, SamAccountName | 
        Format-Table -AutoSize
}

function Check-PasswordExpiration {
    $days = Read-Host "Enter the number of days to check for password expiration"
    $date = (Get-Date).AddDays($days)
    Write-Host "`nListing users whose passwords will expire within $days days..." -ForegroundColor Yellow
    Get-ADUser -Filter {Enabled -eq $true -and PasswordNeverExpires -eq $false} -Properties "DisplayName", "msDS-UserPasswordExpiryTimeComputed" | 
        Select-Object -Property "DisplayName", @{Name="ExpiryDate";Expression={[datetime]::FromFileTime($_."msDS-UserPasswordExpiryTimeComputed")}} | 
        Where-Object {$_.ExpiryDate -le $date} | 
        Sort-Object ExpiryDate | 
        Format-Table -AutoSize
}

function View-GroupMembership {
    $groupName = Read-Host "Enter the group name to check membership"
    Write-Host "`nListing members of group $groupName..." -ForegroundColor Yellow
    try {
        Get-ADGroupMember -Identity $groupName | 
            Select-Object Name, SamAccountName | 
            Format-Table -AutoSize
    } catch {
        Write-Host "Error: Group not found or you don't have permission to view its members." -ForegroundColor Red
    }
}

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

    switch ($choice) {
        "1" { Check-DomainControllers }
        "2" { List-RecentUsers }
        "3" { List-DisabledUsers }
        "4" { Check-PasswordExpiration }
        "5" { View-GroupMembership }
        "6" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

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

This Active Directory Monitoring Tool includes:

A menu with 6 options
Functions for various AD monitoring tasks:
- Checking Domain Controllers status
- Listing recently created users
- Listing disabled user accounts
- Checking password expiration
- Viewing group membership
Use of Active Directory PowerShell cmdlets
Basic error handling
Formatted output for better readability

Key features:

Domain Controller Status: Pings each DC to check if it’s online.
Recent Users: Lists users created within a specified number of days.
Disabled Users: Shows all disabled user accounts.
Password Expiration: Lists users whose passwords will expire soon.
Group Membership: Displays members of a specified group.

This tool provides a quick overview of essential Active Directory metrics and statuses. It’s useful for:

Monitoring the health of Domain Controllers
Tracking recent account creations
Identifying disabled accounts
Managing password policies
Reviewing group memberships

Note: To use this script, you need to:

Run PowerShell as an administrator
Have the Active Directory PowerShell module installed
Have appropriate permissions in the AD environment

This script is suitable for AD administrators who want to perform basic AD health checks and gather information quickly without navigating through multiple tools or writing complex queries.

Advanced System Health Monitor

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

# Advanced System Health Monitor

function Show-Menu {
    Clear-Host
    Write-Host "=== Advanced System Health Monitor ===" -ForegroundColor Cyan
    Write-Host "1.  CPU Information and Usage"
    Write-Host "2.  Memory Usage Details"
    Write-Host "3.  Disk Space and Health"
    Write-Host "4.  Network Statistics"
    Write-Host "5.  Top Resource-Consuming Processes"
    Write-Host "6.  System Uptime and Last Boot Time"
    Write-Host "7.  Installed Windows Updates"
    Write-Host "8.  Event Log Summary"
    Write-Host "9.  Services Status"
    Write-Host "10. Battery Status (for laptops)"
    Write-Host "11. Exit"
}

function Get-CPUInfo {
    Write-Host "`nCPU Information and Usage:" -ForegroundColor Yellow
    $cpu = Get-WmiObject Win32_Processor
    Write-Host "CPU Model: $($cpu.Name)"
    Write-Host "Number of Cores: $($cpu.NumberOfCores)"
    Write-Host "Number of Logical Processors: $($cpu.NumberOfLogicalProcessors)"
    
    $usage = (Get-Counter '\Processor(_Total)\% Processor Time').CounterSamples.CookedValue
    Write-Host "Current CPU Usage: $([math]::Round($usage, 2))%"
}

function Get-MemoryDetails {
    Write-Host "`nMemory Usage Details:" -ForegroundColor Yellow
    $os = Get-CimInstance Win32_OperatingSystem
    $totalMemory = [math]::Round($os.TotalVisibleMemorySize / 1MB, 2)
    $freeMemory = [math]::Round($os.FreePhysicalMemory / 1MB, 2)
    $usedMemory = $totalMemory - $freeMemory
    $percentUsed = [math]::Round(($usedMemory / $totalMemory) * 100, 2)

    Write-Host "Total Memory: $totalMemory GB"
    Write-Host "Used Memory: $usedMemory GB"
    Write-Host "Free Memory: $freeMemory GB"
    Write-Host "Memory Usage: $percentUsed%"

    $pageFile = Get-WmiObject Win32_PageFileUsage
    Write-Host "Page File Size: $([math]::Round($pageFile.AllocatedBaseSize / 1024, 2)) GB"
    Write-Host "Page File Usage: $([math]::Round($pageFile.CurrentUsage / 1024, 2)) GB"
}

function Get-DiskInfo {
    Write-Host "`nDisk Space and Health:" -ForegroundColor Yellow
    $disks = Get-WmiObject Win32_LogicalDisk | Where-Object {$_.DriveType -eq 3}
    foreach ($disk in $disks) {
        $freeSpace = [math]::Round($disk.FreeSpace / 1GB, 2)
        $totalSpace = [math]::Round($disk.Size / 1GB, 2)
        $usedSpace = $totalSpace - $freeSpace
        $percentFree = [math]::Round(($freeSpace / $totalSpace) * 100, 2)
        
        Write-Host "Drive $($disk.DeviceID):"
        Write-Host "  Total: $totalSpace GB"
        Write-Host "  Used: $usedSpace GB"
        Write-Host "  Free: $freeSpace GB"
        Write-Host "  Percent Free: $percentFree%"
    }

    Write-Host "`nDisk Health:"
    Get-PhysicalDisk | ForEach-Object {
        Write-Host "  $($_.FriendlyName): $($_.HealthStatus)"
    }
}

function Get-NetworkStats {
    Write-Host "`nNetwork Statistics:" -ForegroundColor Yellow
    $adapters = Get-NetAdapter | Where-Object Status -eq "Up"
    foreach ($adapter in $adapters) {
        Write-Host "Adapter: $($adapter.Name)"
        $stats = $adapter | Get-NetAdapterStatistics
        Write-Host "  Bytes Received: $([math]::Round($stats.ReceivedBytes / 1MB, 2)) MB"
        Write-Host "  Bytes Sent: $([math]::Round($stats.SentBytes / 1MB, 2)) MB"
    }
}

function Get-TopProcesses {
    Write-Host "`nTop Resource-Consuming Processes:" -ForegroundColor Yellow
    Get-Process | Sort-Object CPU -Descending | Select-Object -First 5 | 
        Format-Table Name, @{Name='CPU (s)'; Expression={$_.CPU.ToString('N2')}}, @{Name='Memory (MB)'; Expression={[math]::Round($_.WorkingSet / 1MB, 2)}} -AutoSize

    Write-Host "`nTop Memory-Consuming Processes:"
    Get-Process | Sort-Object WorkingSet -Descending | Select-Object -First 5 | 
        Format-Table Name, @{Name='Memory (MB)'; Expression={[math]::Round($_.WorkingSet / 1MB, 2)}}, @{Name='CPU (s)'; Expression={$_.CPU.ToString('N2')}} -AutoSize
}

function Get-SystemUptime {
    Write-Host "`nSystem Uptime and Last Boot Time:" -ForegroundColor Yellow
    $os = Get-CimInstance Win32_OperatingSystem
    $uptime = (Get-Date) - $os.LastBootUpTime
    Write-Host "Last Boot Time: $($os.LastBootUpTime)"
    Write-Host "System Uptime: $($uptime.Days) days, $($uptime.Hours) hours, $($uptime.Minutes) minutes"
}

function Get-WindowsUpdates {
    Write-Host "`nLast 5 Installed Windows Updates:" -ForegroundColor Yellow
    Get-HotFix | Sort-Object InstalledOn -Descending | Select-Object -First 5 | 
        Format-Table HotFixID, Description, InstalledOn -AutoSize
}

function Get-EventLogSummary {
    Write-Host "`nEvent Log Summary (Last 24 Hours):" -ForegroundColor Yellow
    $startTime = (Get-Date).AddHours(-24)
    $logs = @('System', 'Application')
    foreach ($log in $logs) {
        $events = Get-WinEvent -LogName $log -MaxEvents 1000 | Where-Object { $_.TimeCreated -ge $startTime }
        $errorCount = ($events | Where-Object { $_.LevelDisplayName -eq 'Error' }).Count
        $warningCount = ($events | Where-Object { $_.LevelDisplayName -eq 'Warning' }).Count
        Write-Host "$log Log:"
        Write-Host "  Errors: $errorCount"
        Write-Host "  Warnings: $warningCount"
    }
}

function Get-ServicesStatus {
    Write-Host "`nCritical Services Status:" -ForegroundColor Yellow
    $services = @('wuauserv', 'WinDefend', 'BITS', 'Dhcp', 'Dnscache', 'LanmanServer')
    foreach ($service in $services) {
        $status = (Get-Service $service).Status
        Write-Host "$service : $status"
    }
}

function Get-BatteryStatus {
    Write-Host "`nBattery Status:" -ForegroundColor Yellow
    $battery = Get-WmiObject Win32_Battery
    if ($battery) {
        Write-Host "Battery Level: $($battery.EstimatedChargeRemaining)%"
        Write-Host "Status: $($battery.BatteryStatus)"
    } else {
        Write-Host "No battery detected. This might be a desktop computer."
    }
}

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

    switch ($choice) {
        "1"  { Get-CPUInfo }
        "2"  { Get-MemoryDetails }
        "3"  { Get-DiskInfo }
        "4"  { Get-NetworkStats }
        "5"  { Get-TopProcesses }
        "6"  { Get-SystemUptime }
        "7"  { Get-WindowsUpdates }
        "8"  { Get-EventLogSummary }
        "9"  { Get-ServicesStatus }
        "10" { Get-BatteryStatus }
        "11" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

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

This Advanced System Health Monitor includes:

A comprehensive menu with 11 options
Detailed functions for various system health checks:
- CPU information and real-time usage
- Detailed memory usage including page file information
- Disk space, usage, and health status
- Network statistics for active adapters
- Top CPU and memory-consuming processes
- System uptime and last boot time
- Recent Windows updates
- Event log summary for the last 24 hours
- Status of critical system services
- Battery status for laptops
Use of advanced PowerShell cmdlets and WMI objects
Formatted output for better readability
More comprehensive system information gathering

This tool provides a detailed overview of system health and performance metrics. It’s useful for:

Advanced system monitoring and troubleshooting
Identifying potential issues across various system components
Gathering comprehensive system information for diagnostics
Monitoring critical services and system events

This script is suitable for IT professionals, system administrators, or advanced users who need detailed system health information. It provides a single interface to access a wide range of system metrics and statuses, which would otherwise require navigating through multiple system tools or running several different commands.

Simple System Health Monitor

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

# Simple System Health Monitor

function Show-Menu {
    Clear-Host
    Write-Host "=== Simple System Health Monitor ===" -ForegroundColor Cyan
    Write-Host "1. Check CPU Usage"
    Write-Host "2. Check Memory Usage"
    Write-Host "3. Check Disk Space"
    Write-Host "4. List Top 5 CPU-Consuming Processes"
    Write-Host "5. Check System Uptime"
    Write-Host "6. Exit"
}

function Check-CPUUsage {
    $cpu = Get-WmiObject Win32_Processor | Measure-Object -Property LoadPercentage -Average | Select-Object Average
    Write-Host "`nCurrent CPU Usage: $($cpu.Average)%" -ForegroundColor Yellow
}

function Check-MemoryUsage {
    $os = Get-Ciminstance Win32_OperatingSystem
    $totalMemory = [math]::Round($os.TotalVisibleMemorySize / 1MB, 2)
    $freeMemory = [math]::Round($os.FreePhysicalMemory / 1MB, 2)
    $usedMemory = $totalMemory - $freeMemory
    $percentUsed = [math]::Round(($usedMemory / $totalMemory) * 100, 2)

    Write-Host "`nMemory Usage:" -ForegroundColor Yellow
    Write-Host "Total Memory: $totalMemory GB"
    Write-Host "Used Memory: $usedMemory GB"
    Write-Host "Free Memory: $freeMemory GB"
    Write-Host "Percent Used: $percentUsed%"
}

function Check-DiskSpace {
    $disks = Get-WmiObject Win32_LogicalDisk | Where-Object {$_.DriveType -eq 3}
    Write-Host "`nDisk Space:" -ForegroundColor Yellow
    foreach ($disk in $disks) {
        $freeSpace = [math]::Round($disk.FreeSpace / 1GB, 2)
        $totalSpace = [math]::Round($disk.Size / 1GB, 2)
        $usedSpace = $totalSpace - $freeSpace
        $percentFree = [math]::Round(($freeSpace / $totalSpace) * 100, 2)
        
        Write-Host "Drive $($disk.DeviceID):"
        Write-Host "  Total: $totalSpace GB"
        Write-Host "  Used: $usedSpace GB"
        Write-Host "  Free: $freeSpace GB"
        Write-Host "  Percent Free: $percentFree%"
        Write-Host ""
    }
}

function Get-TopCPUProcesses {
    Write-Host "`nTop 5 CPU-Consuming Processes:" -ForegroundColor Yellow
    Get-Process | Sort-Object CPU -Descending | Select-Object -First 5 | 
        Format-Table Name, @{Name='CPU (s)'; Expression={$_.CPU.ToString('N2')}}, @{Name='Memory (MB)'; Expression={[math]::Round($_.WorkingSet / 1MB, 2)}} -AutoSize
}

function Check-Uptime {
    $uptime = (Get-Date) - (Get-CimInstance Win32_OperatingSystem).LastBootUpTime
    Write-Host "`nSystem Uptime: $($uptime.Days) days, $($uptime.Hours) hours, $($uptime.Minutes) minutes" -ForegroundColor Yellow
}

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

    switch ($choice) {
        "1" { Check-CPUUsage }
        "2" { Check-MemoryUsage }
        "3" { Check-DiskSpace }
        "4" { Get-TopCPUProcesses }
        "5" { Check-Uptime }
        "6" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

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

This System Health Monitor includes:

A menu with 6 options
Functions for various system health checks:
- Checking CPU usage
- Checking memory usage
- Checking disk space
- Listing top CPU-consuming processes
- Checking system uptime
Use of PowerShell cmdlets like Get-WmiObject, Get-CimInstance, and Get-Process
Basic calculations for memory and disk usage percentages
Formatted output for better readability

This tool provides a quick overview of essential system health metrics. It’s useful for:

Monitoring system performance
Identifying potential resource bottlenecks
Checking available disk space
Identifying processes that are consuming high CPU
Determining how long the system has been running

This script is suitable for users who want to perform basic system health checks without needing to navigate through multiple system tools or commands. It provides a simple interface for accessing important system information quickly and easily.

Simple Network Diagnostics Tool

08/08/2024/0 Comments/in Miscellaneous, Program/by Laszlo Bocso

# Simple Network Diagnostics Tool

function Show-Menu {
    Clear-Host
    Write-Host "=== Simple Network Diagnostics Tool ===" -ForegroundColor Cyan
    Write-Host "1. Ping a host"
    Write-Host "2. Check DNS resolution"
    Write-Host "3. View IP configuration"
    Write-Host "4. Test internet connectivity"
    Write-Host "5. Exit"
}

function Ping-Host {
    $host_name = Read-Host "Enter the host name or IP address to ping"
    Write-Host "`nPinging $host_name..." -ForegroundColor Yellow
    ping $host_name
}

function Check-DNS {
    $dns_name = Read-Host "Enter the domain name to resolve"
    Write-Host "`nResolving $dns_name..." -ForegroundColor Yellow
    nslookup $dns_name
}

function View-IPConfig {
    Write-Host "`nIP Configuration:" -ForegroundColor Yellow
    ipconfig /all
}

function Test-Internet {
    Write-Host "`nTesting internet connectivity..." -ForegroundColor Yellow
    $result = Test-Connection -ComputerName "www.google.com" -Count 2 -Quiet
    if ($result) {
        Write-Host "Internet is accessible." -ForegroundColor Green
    } else {
        Write-Host "Internet is not accessible." -ForegroundColor Red
    }
}

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

    switch ($choice) {
        "1" { Ping-Host }
        "2" { Check-DNS }
        "3" { View-IPConfig }
        "4" { Test-Internet }
        "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 simplified Network Diagnostics Tool includes:

A concise menu with 5 options
Basic functions for essential network diagnostic tasks:
- Pinging a host
- Checking DNS resolution
- Viewing IP configuration
- Testing internet connectivity
Use of simple PowerShell cmdlets and system commands
Minimal error handling
Easy-to-read output

This script provides a straightforward set of tools for basic network diagnostics and troubleshooting. It’s suitable for beginners or for quick checks of common network issues. The tool uses familiar commands like ping, nslookup, and ipconfig, which are widely recognized and easy to interpret.

This simplified version is more accessible for users who need to perform basic network diagnostics without the complexity of more advanced features.

Latest News

Azure Active Directory Monitoring Tool

Advanced Active Directory Monitoring Tool

Simple Active Directory Monitoring Tool

Advanced System Health Monitor

Simple System Health Monitor

Simple Network Diagnostics Tool

Windows PowerShell

Links

Contact

Sitemap