Blog

# Quick Windows 11 Security Features Check

# Check if the script is running with administrator privileges
if (-not ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) {
    Write-Warning "This script should be run as Administrator for full functionality."
}

# Microsoft Defender Status
Write-Host "`nMicrosoft Defender Status:" -ForegroundColor Cyan
$defenderStatus = Get-MpComputerStatus
Write-Host "Antivirus Enabled: " -NoNewline
if ($defenderStatus.AntivirusEnabled) { Write-Host "Yes" -ForegroundColor Green } else { Write-Host "No" -ForegroundColor Red }
Write-Host "Real-Time Protection: " -NoNewline
if ($defenderStatus.RealTimeProtectionEnabled) { Write-Host "Yes" -ForegroundColor Green } else { Write-Host "No" -ForegroundColor Red }
Write-Host "Tamper Protected: " -NoNewline
if ($defenderStatus.IsTamperProtected) { Write-Host "Yes" -ForegroundColor Green } else { Write-Host "No" -ForegroundColor Red }

# Firewall Status
Write-Host "`nFirewall Status:" -ForegroundColor Cyan
$firewallStatus = Get-NetFirewallProfile
foreach ($profile in $firewallStatus) {
    Write-Host "$($profile.Name) Profile: " -NoNewline
    if ($profile.Enabled) { Write-Host "Enabled" -ForegroundColor Green } else { Write-Host "Disabled" -ForegroundColor Red }
}

# Secure Boot Status
Write-Host "`nSecure Boot:" -ForegroundColor Cyan
try {
    $secureBoot = Confirm-SecureBootUEFI
    Write-Host "Status: " -NoNewline
    if ($secureBoot) { Write-Host "Enabled" -ForegroundColor Green } else { Write-Host "Disabled" -ForegroundColor Red }
} catch {
    Write-Host "Status: Not supported or error occurred" -ForegroundColor Yellow
}

# BitLocker Status
Write-Host "`nBitLocker Status:" -ForegroundColor Cyan
$bitLockerStatus = Get-BitLockerVolume
foreach ($volume in $bitLockerStatus) {
    Write-Host "$($volume.MountPoint) Protection: " -NoNewline
    if ($volume.ProtectionStatus -eq "On") { Write-Host "On" -ForegroundColor Green } else { Write-Host "Off" -ForegroundColor Red }
}

# VBS and Credential Guard
Write-Host "`nVBS and Credential Guard:" -ForegroundColor Cyan
try {
    $deviceGuard = Get-CimInstance -ClassName Win32_DeviceGuard -ErrorAction Stop
    $vbsStatus = if ($deviceGuard.VirtualizationBasedSecurityStatus -eq 2) { "Enabled" } else { "Disabled" }
    $credGuard = if ($deviceGuard.SecurityServicesRunning -contains 1) { "Enabled" } else { "Disabled" }
    Write-Host "VBS: " -NoNewline
    if ($vbsStatus -eq "Enabled") { Write-Host "Enabled" -ForegroundColor Green } else { Write-Host "Disabled" -ForegroundColor Red }
    Write-Host "Credential Guard: " -NoNewline
    if ($credGuard -eq "Enabled") { Write-Host "Enabled" -ForegroundColor Green } else { Write-Host "Disabled" -ForegroundColor Red }
} catch {
    Write-Host "VBS and Credential Guard status not available on this system." -ForegroundColor Yellow
}

# TPM Status
Write-Host "`nTPM Status:" -ForegroundColor Cyan
$tpmStatus = Get-Tpm
Write-Host "TPM Present: " -NoNewline
if ($tpmStatus.TpmPresent) { Write-Host "Yes" -ForegroundColor Green } else { Write-Host "No" -ForegroundColor Red }
Write-Host "TPM Ready: " -NoNewline
if ($tpmStatus.TpmReady) { Write-Host "Yes" -ForegroundColor Green } else { Write-Host "No" -ForegroundColor Red }

Write-Host "`nSecurity Features Check Complete" -ForegroundColor Cyan

# PowerShell script to check for Windows updates and list pending updates

try {
    Write-Output "Checking for updates..."
    
    # Create a new update session
    $session = New-Object -ComObject Microsoft.Update.Session
    
    # Create an update searcher
    $searcher = $session.CreateUpdateSearcher()
    
    # Set the search criteria to find updates that are not installed and not hidden
    $criteria = "IsInstalled=0 and IsHidden=0"
    
    # Perform the search
    $result = $searcher.Search($criteria)
    
    # Check if the search was successful (ResultCode 2 means Succeeded)
    if ($result.ResultCode -eq 2) {
        $updates = $result.Updates
        if ($updates.Count -gt 0) {
            Write-Output "Found $($updates.Count) pending updates:"
            $counter = 1
            foreach ($update in $updates) {
                # Get the KB article ID if available
                $kb = if ($update.KBArticleIDs.Count -gt 0) { $update.KBArticleIDs[0] } else { "N/A" }
                # Check if the update is downloaded
                $status = if ($update.IsDownloaded) { "Downloaded" } else { "Not Downloaded" }
                Write-Output "$counter. Title: $($update.Title) (KB$kb) - $status"
                Write-Output "   Description: $($update.Description)"
                Write-Output ""
                $counter++
            }
        } else {
            Write-Output "No pending updates found."
        }
    } else {
        Write-Output "Update search failed with result code $($result.ResultCode)"
    }
} catch {
    Write-Output "An error occurred: $($_.Exception.Message)"
}

# Get OS Information
$os = Get-WmiObject -Class Win32_OperatingSystem
$installDate = [System.Management.ManagementDateTimeConverter]::ToDateTime($os.InstallDate)
Write-Output "Operating System Information:"
Write-Output "OS Name: $($os.Caption)"
Write-Output "Version: $($os.Version)"
Write-Output "Build Number: $($os.BuildNumber)"
Write-Output "Installation Date: $installDate"
Write-Output ""

# Get Processor Information
$processors = Get-WmiObject -Class Win32_Processor
$totalCores = ($processors | Measure-Object -Property NumberOfCores -Sum).Sum
$totalThreads = ($processors | Measure-Object -Property NumberOfLogicalProcessors -Sum).Sum
$processorName = $processors[0].Name
$maxClockSpeed = $processors[0].MaxClockSpeed
Write-Output "Processor Information:"
Write-Output "Processor: $processorName"
Write-Output "Total Cores: $totalCores"
Write-Output "Total Threads: $totalThreads"
Write-Output "Max Clock Speed: $maxClockSpeed MHz"
Write-Output ""

# Get Memory Information
$memory = Get-WmiObject -Class Win32_PhysicalMemory
$totalRAM = [math]::Round(($memory | Measure-Object -Property Capacity -Sum).Sum / 1GB, 2)
Write-Output "Memory Information:"
Write-Output "Total RAM: $totalRAM GB"
Write-Output ""

# Get Disk Information
$disks = Get-WmiObject -Class Win32_DiskDrive
Write-Output "Disk Information:"
foreach ($disk in $disks) {
    $sizeGB = [math]::Round($disk.Size / 1GB, 2)
    Write-Output "Disk Model: $($disk.Model)"
    Write-Output "Size: $sizeGB GB"
    Write-Output ""
}

# Get Graphics Information
$gpus = Get-WmiObject -Class Win32_VideoController
Write-Output "Graphics Information:"
foreach ($gpu in $gpus) {
    Write-Output "Graphics Card: $($gpu.Name)"
    Write-Output "Resolution: $($gpu.VideoModeDescription)"
    Write-Output ""
}

# Get Network Information
$adapters = Get-NetAdapter | Where-Object {$_.Status -eq 'Up'}
Write-Output "Network Information:"
foreach ($adapter in $adapters) {
    Write-Output "Adapter Name: $($adapter.Name)"
    Write-Output "MAC Address: $($adapter.MacAddress)"
    $ipAddresses = Get-NetIPAddress -InterfaceIndex $adapter.InterfaceIndex | Where-Object {$_.AddressFamily -eq 'IPv4'}
    Write-Output "IP Addresses:"
    foreach ($ip in $ipAddresses) {
        Write-Output "  $($ip.IPAddress)"
    }
    Write-Output ""
}

# Get Motherboard and BIOS Information
$motherboard = Get-WmiObject -Class Win32_BaseBoard
$bios = Get-WmiObject -Class Win32_BIOS
$biosDate = [System.Management.ManagementDateTimeConverter]::ToDateTime($bios.ReleaseDate)
Write-Output "Motherboard and BIOS Information:"
Write-Output "Motherboard Manufacturer: $($motherboard.Manufacturer)"
Write-Output "Motherboard Model: $($motherboard.Product)"
Write-Output "BIOS Manufacturer: $($bios.Manufacturer)"
Write-Output "BIOS Version: $($bios.Version)"
Write-Output "BIOS Release Date: $biosDate"

# Get OS name
$os = Get-CimInstance -ClassName Win32_OperatingSystem
$osName = $os.Caption

# Get OS version
$osVersion = [System.Environment]::OSVersion.Version

# Display OS name and version
Write-Output "Operating System: $osName"
Write-Output "Version: $($osVersion.Major).$($osVersion.Minor).$($osVersion.Build).$($osVersion.Revision)"

# Get and display installed updates
Write-Output "Installed Updates:"
Get-HotFix | Sort-Object InstalledOn | Format-Table HotFixID, Description, InstalledOn

# Function: Recursively select a folder by listing subdirectories
function Select-Folder($startingPath) {
    $currentPath = $startingPath
    while ($true) {
        Write-Host "`nCurrent Directory: $currentPath" -ForegroundColor Cyan

        # Get subdirectories (if any)
        $subDirs = Get-ChildItem -Path $currentPath -Directory -ErrorAction SilentlyContinue

        if (!$subDirs -or $subDirs.Count -eq 0) {
            Write-Host "No subdirectories found in $currentPath. Using this folder."
            break
        }

        # List options: 0 to select current folder, then list each subfolder with a number
        Write-Host "0: [Select this directory]"
        $index = 1
        foreach ($dir in $subDirs) {
            Write-Host ("{0}: {1}" -f $index, $dir.Name)
            $index++
        }

        $choice = Read-Host "Enter the number to navigate into a folder, or 0 to select the current directory"

        if (-not [int]::TryParse($choice, [ref]$null)) {
            Write-Host "Invalid input. Please enter a number."
            continue
        }

        $choice = [int]$choice

        if ($choice -eq 0) {
            break
        }
        elseif ($choice -ge 1 -and $choice -le $subDirs.Count) {
            $currentPath = $subDirs[$choice - 1].FullName
        }
        else {
            Write-Host "Invalid selection. Please try again."
        }
    }
    return $currentPath
}

# Prompt the user to choose the directory selection method
Write-Host "Select target directory method:" -ForegroundColor Green
Write-Host "1: Type the full directory path"
Write-Host "2: Navigate directories using a numbered list"
$method = Read-Host "Enter 1 or 2"

if ($method -eq "1") {
    $targetDirectory = Read-Host "Enter the target directory path"
    if (-not (Test-Path $targetDirectory)) {
        Write-Host "Directory '$targetDirectory' does not exist. Exiting." -ForegroundColor Red
        exit
    }
}
elseif ($method -eq "2") {
    # Optionally allow the user to set a starting directory; default is C:\
    $startingPath = Read-Host "Enter starting directory path (press Enter for default C:\)"
    if ([string]::IsNullOrWhiteSpace($startingPath)) {
        $startingPath = "C:\"
    }
    if (-not (Test-Path $startingPath)) {
        Write-Host "The starting directory '$startingPath' does not exist. Exiting." -ForegroundColor Red
        exit
    }
    $targetDirectory = Select-Folder $startingPath
    Write-Host "Selected Directory: $targetDirectory" -ForegroundColor Green
}
else {
    Write-Host "Invalid selection. Exiting." -ForegroundColor Red
    exit
}

# Prompt user for the base folder name
$baseName = Read-Host "Enter the base folder name for the folders to be created"

# Prompt user for the number of folders to create
$numFoldersInput = Read-Host "Enter the number of folders to create"
if (-not [int]::TryParse($numFoldersInput, [ref]$null)) {
    Write-Host "The number of folders must be a valid integer. Exiting." -ForegroundColor Red
    exit
}
$numFolders = [int]$numFoldersInput

# Create folders sequentially
for ($i = 1; $i -le $numFolders; $i++) {
    # Construct folder name: "BaseName 1", "BaseName 2", etc.
    $folderName = "{0} {1}" -f $baseName, $i
    $folderPath = Join-Path $targetDirectory $folderName

    if (-not (Test-Path $folderPath)) {
        New-Item -Path $folderPath -ItemType Directory | Out-Null
        Write-Host "Created folder: $folderPath" -ForegroundColor Yellow
    }
    else {
        Write-Host "Folder already exists: $folderPath" -ForegroundColor DarkYellow
    }
}

# Define registry paths for 64-bit and 32-bit applications
$registryPaths = @(
    "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*"
)

# Retrieve applications from the registry
$installedApps = foreach ($path in $registryPaths) {
    Get-ItemProperty -Path $path -ErrorAction SilentlyContinue |
        Where-Object { $_.DisplayName -and $_.DisplayVersion }
}

# Display the results in a formatted table
$installedApps |
    Select-Object DisplayName, DisplayVersion, Publisher, InstallDate |
    Sort-Object DisplayName |
    Format-Table -AutoSize