---

<#
.SYNOPSIS
    Надежная инвентаризация сервисных учётных записей (без WinRM, на RPC).
#>

#region ===== Конфигурация =====
$DomainName         = "mydomain.organization.ru"
$OUUserServices     = "OU=ServiceAccounts,DC=mydomain,DC=organization,DC=ru"
$OUServers          = "OU=Servers,DC=mydomain,DC=organization,DC=ru"
$ResultUserAccounts = "C:\Reports\UserAccounts.csv"

$LogRetentionDays   = 30   # Глубина анализа логов
$AccountBatchSize   = 10   # Кол-во УЗ в одном XPath-запросе (чтобы не превысить лимит)
#endregion

#region ===== Утилита логирования =====
function Write-ScanLog {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, Position=0)][string]$Message,
        [ValidateSet('Info','Warning','Error','Success','Header')][string]$Level = 'Info'
    )
    $ts    = Get-Date -Format "HH:mm:ss"
    $color = switch ($Level) {
        'Info'    { 'Gray'   }
        'Warning' { 'Yellow' }
        'Error'   { 'Red'    }
        'Success' { 'Green'  }
        'Header'  { 'Cyan'   }
    }
    if ($Level -eq 'Header') {
        Write-Host ""
        Write-Host ("=" * 78) -ForegroundColor $color
        Write-Host "== $Message" -ForegroundColor $color
        Write-Host ("=" * 78) -ForegroundColor $color
    } else {
        Write-Host "[$ts] $Message" -ForegroundColor $color
    }
}
#endregion

#region ===== Функции сбора данных AD =====
function Get-TargetAccounts {
    [CmdletBinding()]
    param([string]$DomainName, [string]$OUUserServices)
    Write-ScanLog "Чтение учётных записей из $OUUserServices ..."
    try {
        $acc = @(Get-ADUser -Server $DomainName -SearchBase $OUUserServices -SearchScope Subtree `
                -Filter { Enabled -eq $true } `
                -Properties DisplayName, SamAccountName, UserPrincipalName |
            Select-Object @{n='DisplayName'; e={ if ($_.DisplayName) { $_.DisplayName } else { $_.SamAccountName } }},
                          SamAccountName, UserPrincipalName)
        Write-ScanLog "  Получено учётных записей: $($acc.Count)" -Level Success
        return $acc
    } catch {
        Write-ScanLog "  ОШИБКА: $_" -Level Error
        return @()
    }
}

function Get-TargetServers {
    [CmdletBinding()]
    param([string]$DomainName, [string]$OUServers)
    Write-ScanLog "Чтение серверов из $OUServers ..."
    try {
        $srv = @(Get-ADComputer -Server $DomainName -SearchBase $OUServers -SearchScope Subtree `
                -Filter { Enabled -eq $true } -Properties DNSHostName |
            Select-Object -ExpandProperty DNSHostName -ErrorAction SilentlyContinue)
        Write-ScanLog "  Получено серверов: $($srv.Count)" -Level Success
        return $srv
    } catch {
        Write-ScanLog "  ОШИБКА: $_" -Level Error
        return @()
    }
}

function Resolve-AccountFromIdentity {
    [CmdletBinding()]
    param([string]$Identity, [hashtable]$Lookup)
    if ([string]::IsNullOrWhiteSpace($Identity)) { return $null }
    $id    = $Identity.Trim()
    $short = (($id -split '\\')[-1] -split '@')[0].ToLower()
    if ($Lookup.ContainsKey($short))        { return $Lookup[$short] }
    if ($Lookup.ContainsKey($id.ToLower())) { return $Lookup[$id.ToLower()] }
    return $null
}
#endregion

#region ===== Функции опроса серверов (RPC/DCOM) =====
function Get-ServerServices {
    [CmdletBinding()]
    param([string]$ComputerName)
    try {
        # Get-CimInstance работает по DCOM (порт 135), надежнее WinRM
        Get-CimInstance -ClassName Win32_Service -ComputerName $ComputerName -ErrorAction Stop |
            Select-Object Name, DisplayName, StartName
    } catch { return $null }
}

function Get-ServerScheduledTasks {
    [CmdletBinding()]
    param([string]$ComputerName)
    try {
        $raw = schtasks /query /s $ComputerName /fo CSV /v 2>$null
        if (-not $raw) { return $null }
        $raw | ConvertFrom-Csv |
            Where-Object { $_."Run As User" -and $_."Run As User" -ne 'N/A' } |
            Select-Object TaskName, @{n='StartName'; e={ $_."Run As User" }}
    } catch { return $null }
}

function Get-ServerIISAppPools {
    [CmdletBinding()]
    param([string]$ComputerName)
    try {
        # Используем CIM вместо Invoke-Command. Работает на IIS 7+ (Windows 2008 R2+)
        $pools = @(Get-CimInstance -Namespace 'root/WebAdministration' -ClassName 'ApplicationPool' -ComputerName $ComputerName -ErrorAction Stop)
        $res = @()
        foreach ($p in $pools) {
            if ($p.ProcessModel.UserName) {
                $res += [PSCustomObject]@{ Name = $p.Name; StartName = $p.ProcessModel.UserName }
            }
        }
        return $res
    } catch { return $null } # Если IIS нет или WMI-провайдер не отвечает
}
#endregion

#region ===== Анализ журналов DC (последовательный, RPC) =====
function Get-DCLogonEvents {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][string[]]$AccountSams,
        [Parameter(Mandatory)][string]$DomainName,
        [int]$Days = 30,
        [int]$BatchSize = 10
    )

    $results = New-Object System.Collections.Generic.List[object]
    if (-not $AccountSams -or $AccountSams.Count -eq 0) { return $results }

    # 1. Поиск DC
    Write-ScanLog "  Поиск DC для домена '$DomainName'..."
    try {
        $dcs = @(Get-ADDomainController -Server $DomainName -Filter * -ErrorAction Stop | Select-Object -ExpandProperty Name)
    } catch {
        Write-ScanLog "  ОШИБКА при получении списка DC: $_" -Level Error
        return $results
    }
    Write-ScanLog "  Найдено DC ($($dcs.Count)): $($dcs -join ', ')" -Level Success

    # 2. Подготовка XPath-пакетов
    $startTimeUtc = (Get-Date).AddDays(-$Days).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ss.fffZ")
    $logonCond = (@('3','4','5','8','9','10') | ForEach-Object { "Data[@Name='LogonType']='$_'" }) -join ' or '

    $xPaths = @()
    for ($i = 0; $i -lt $AccountSams.Count; $i += $BatchSize) {
        $endIdx = [Math]::Min($i + $BatchSize - 1, $AccountSams.Count - 1)
        $batch = $AccountSams[$i..$endIdx]
        
        $escapedUsers = $batch | ForEach-Object { [System.Security.SecurityElement]::Escape($_) }
        $userCond = ($escapedUsers | ForEach-Object { "Data[@Name='TargetUserName']='$_'" }) -join ' or '
        
        $xpath = "*[System[(EventID=4624) and TimeCreated[@SystemTime>='$startTimeUtc']] " +
                 "and EventData[($userCond) and ($logonCond)]]"
                 
        $xPaths += [PSCustomObject]@{ XPath = $xpath; Accounts = $batch }
    }

    Write-ScanLog "  Сгенерировано $($xPaths.Count) XPath-пакетов (по $BatchSize УЗ)."
    Write-ScanLog "  Начинаем последовательный опрос DC (через RPC)..." -Level Header

    $allRawResults = @()

    # 3. Обработка DC по очереди
    foreach ($dc in $dcs) {
        Write-ScanLog "=== Анализ логов на DC: $dc ===" -Level Header
        $batchNum = 0
        
        foreach ($item in $xPaths) {
            $batchNum++
            $accList = $item.Accounts -join ', '
            if ($accList.Length -gt 60) { $accList = $accList.Substring(0, 57) + "..." }
            
            Write-ScanLog "  [$dc] Запрос $batchNum/$($xPaths.Count) (УЗ: $accList)"

            try {
                # Get-WinEvent -ComputerName работает по RPC (EventLog Remoting). 
                # Это встроенный механизм Windows, не требующий настройки WinRM.
                $events = @(Get-WinEvent -ComputerName $dc -LogName 'Security' -FilterXPath $item.XPath -MaxEvents 50000 -ErrorAction Stop)
            } catch {
                if ($_.FullyQualifiedErrorId -match 'NoMatchingEventsFound') {
                    $events = @()
                } else {
                    Write-ScanLog "  [$dc] ОШИБКА доступа к журналу: $($_.Exception.Message)" -Level Warning
                    continue
                }
            }

            # Мгновенный парсинг и вывод статистики по пакету
            $parsed = @($events | ForEach-Object {
                [PSCustomObject]@{
                    TargetUser = $_.Properties[5].Value
                    LogonType  = $_.Properties[8].Value
                    SourceHost = $_.Properties[18].Value
                }
            })

            Write-ScanLog "  [$dc] Найдено событий: $($parsed.Count)"

            if ($parsed.Count -gt 0) {
                $grouped = $parsed | Group-Object TargetUser
                foreach ($g in $grouped) {
                    $uniqueHosts = @($g.Group | Where-Object { $_.SourceHost -and $_.SourceHost -ne '-' } | Select-Object -ExpandProperty SourceHost -Unique)
                    Write-ScanLog ("    -> {0,-20} : событий {1,-4} | серверов {2}" -f $g.Name, $g.Count, $uniqueHosts.Count) -Level Info
                }
            }

            $allRawResults += $parsed
        }
    }
    Write-ScanLog "  Сбор журналов завершен." -Level Success

    # 4. Фильтрация и итоговая сводка
    $validSams = [System.Collections.Generic.HashSet[string]]::new([string[]]$AccountSams, [System.StringComparer]::OrdinalIgnoreCase)
    $validEvents = @()
    
    foreach ($ev in $allRawResults) {
        if (-not $ev.TargetUser -or -not $validSams.Contains($ev.TargetUser)) { continue }
        $src = $ev.SourceHost
        if (-not $src -or $src -eq '-') { continue }
        $src = $src -replace '^\\\\', ''
        
        $validEvents += [PSCustomObject]@{
            AccountSam = $ev.TargetUser
            Server     = $src
            WhereUsed  = "Журнал входа DC (4624, logon type $($ev.LogonType))"
        }
        $results.Add($validEvents[-1])
    }

    Write-ScanLog "  ОБЩАЯ СВОДКА ПО ВСЕМ DC:" -Level Header
    $groupedEvents = $validEvents | Group-Object -Property AccountSam -AsHashTable -AsString
    
    foreach ($sam in $AccountSams) {
        if ($groupedEvents.ContainsKey($sam)) {
            $evs = $groupedEvents[$sam]
            $uniqueSrvCount = @($evs | Select-Object -ExpandProperty Server -Unique).Count
            Write-ScanLog ("    {0,-25} : событий {1,-5} | уникальных серверов: {2}" -f $sam, $evs.Count, $uniqueSrvCount) -Level Success
        } else {
            Write-ScanLog ("    {0,-25} : событий 0" -f $sam) -Level Info
        }
    }
    Write-Host ""

    return $results
}
#endregion

#region ===== Слияние с CSV =====
function Merge-ScanResults {
    [CmdletBinding()]
    param([string]$CsvPath, [AllowEmptyCollection()][System.Collections.Generic.List[object]]$NewResults)

    $now    = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $merged = @{}

    if (Test-Path $CsvPath) {
        Write-ScanLog "Загрузка существующего CSV: $CsvPath"
        $existing = @(Import-Csv -Path $CsvPath -Encoding UTF8)
        Write-ScanLog "  Строк в файле: $($existing.Count)"
        foreach ($row in $existing) {
            $k = "$($row.'Логин')|$($row.'Имя сервера')|$($row.'Где используется')"
            $merged[$k] = $row
        }
    } else {
        Write-ScanLog "Существующий CSV отсутствует — создаётся новый."
    }

    $added = 0; $updated = 0
    foreach ($newRow in $NewResults) {
        $k = "$($newRow.'Логин')|$($newRow.'Имя сервера')|$($newRow.'Где используется')"
        if ($merged.ContainsKey($k)) {
            $merged[$k].'Дата получения информации' = $now
            if ($newRow.'Имя учетной записи') { $merged[$k].'Имя учетной записи' = $newRow.'Имя учетной записи' }
            $updated++
        } else {
            $merged[$k] = [PSCustomObject]@{
                'Имя учетной записи'        = $newRow.'Имя учетной записи'
                'Логин'                     = $newRow.'Логин'
                'Имя сервера'               = $newRow.'Имя сервера'
                'Где используется'          = $newRow.'Где используется'
                'Дата получения информации' = $now
            }
            $added++
        }
    }

    $dir = Split-Path $CsvPath -Parent
    if ($dir -and -not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }

    $merged.Values | Sort-Object 'Логин', 'Имя сервера', 'Где используется' | Export-Csv -Path $CsvPath -NoTypeInformation -Encoding UTF8
    Write-ScanLog "  Добавлено: $added; обновлено: $updated; всего строк: $($merged.Count)" -Level Success
}
#endregion

#region ===== Оркестратор =====
function Invoke-ServiceAccountScan {
    [CmdletBinding()]
    param(
        [string]$DomainName, [string]$OUUserServices, [string]$OUServers, [string]$ResultPath,
        [int]$LogDays = 30, [int]$BatchSize = 10, [switch]$SkipDCScan
    )

    $total = [System.Diagnostics.Stopwatch]::StartNew()
    Write-ScanLog "СТАРТ СКАНИРОВАНИЯ: $DomainName" -Level Header

    # Этап 1
    Write-ScanLog "ЭТАП 1/5: Учётные записи" -Level Header
    $accounts = Get-TargetAccounts -DomainName $DomainName -OUUserServices $OUUserServices
    if (-not $accounts -or $accounts.Count -eq 0) { Write-ScanLog "Нет учётных записей — выход." -Level Error; return }

    # Этап 2
    Write-ScanLog "ЭТАП 2/5: Серверы" -Level Header
    $servers = Get-TargetServers -DomainName $DomainName -OUServers $OUServers
    if (-not $servers -or $servers.Count -eq 0) { Write-ScanLog "Нет серверов — выход." -Level Error; return }

    $lookup = @{}
    foreach ($acc in $accounts) {
        if ($acc.SamAccountName)    { $lookup[$acc.SamAccountName.ToLower()]    = $acc }
        if ($acc.UserPrincipalName) { $lookup[$acc.UserPrincipalName.ToLower()] = $acc }
    }

    $results = New-Object System.Collections.Generic.List[object]

    # Этап 3
    Write-ScanLog "ЭТАП 3/5: Сканирование $($servers.Count) серверов" -Level Header
    $i = 0
    foreach ($server in $servers) {
        $i++
        $swSrv = [System.Diagnostics.Stopwatch]::StartNew()
        Write-ScanLog "  [$i/$($servers.Count)] $server ..."

        $svcCount = 0
        foreach ($svc in (Get-ServerServices -ComputerName $server)) {
            $acc = Resolve-AccountFromIdentity -Identity $svc.StartName -Lookup $lookup
            if ($acc) {
                $svcCount++
                $results.Add([PSCustomObject]@{ 'Имя учетной записи'=$acc.DisplayName; 'Логин'=$acc.SamAccountName; 'Имя сервера'=$server; 'Где используется'="Служба: $($svc.DisplayName) ($($svc.Name))" })
            }
        }

        $taskCount = 0
        foreach ($t in (Get-ServerScheduledTasks -ComputerName $server)) {
            $acc = Resolve-AccountFromIdentity -Identity $t.StartName -Lookup $lookup
            if ($acc) {
                $taskCount++
                $results.Add([PSCustomObject]@{ 'Имя учетной записи'=$acc.DisplayName; 'Логин'=$acc.SamAccountName; 'Имя сервера'=$server; 'Где используется'="Планировщик: $($t.TaskName)" })
            }
        }

        $iisCount = 0
        foreach ($p in (Get-ServerIISAppPools -ComputerName $server)) {
            $acc = Resolve-AccountFromIdentity -Identity $p.StartName -Lookup $lookup
            if ($acc) {
                $iisCount++
                $results.Add([PSCustomObject]@{ 'Имя учетной записи'=$acc.DisplayName; 'Логин'=$acc.SamAccountName; 'Имя сервера'=$server; 'Где используется'="IIS пул: $($p.Name)" })
            }
        }

        $swSrv.Stop()
        $summary = "служб=$svcCount, задач=$taskCount, IIS=$iisCount, время=$($swSrv.Elapsed.TotalSeconds.ToString('0.0'))с"
        if (($svcCount + $taskCount + $iisCount) -gt 0) {
            Write-ScanLog "      найдено: $summary" -Level Success
        } else {
            Write-ScanLog "      не найдено: $summary"
        }
    }

    # Этап 4
    Write-ScanLog "ЭТАП 4/5: Анализ журналов безопасности DC" -Level Header
    if ($SkipDCScan) {
        Write-ScanLog "  Пропущен по флагу -SkipDCScan." -Level Warning
    } else {
        $swDC = [System.Diagnostics.Stopwatch]::StartNew()
        $sams = $accounts | Select-Object -ExpandProperty SamAccountName
        
        $dcEvents = Get-DCLogonEvents -AccountSams $sams -DomainName $DomainName -Days $LogDays -BatchSize $BatchSize
        $swDC.Stop()

        Write-ScanLog "  Событий к обработке: $($dcEvents.Count). Время этапа: $($swDC.Elapsed.TotalSeconds.ToString('0.0'))с"

        foreach ($ev in $dcEvents) {
            $acc = Resolve-AccountFromIdentity -Identity $ev.AccountSam -Lookup $lookup
            if ($acc) {
                $results.Add([PSCustomObject]@{ 'Имя учетной записи'=$acc.DisplayName; 'Логин'=$acc.SamAccountName; 'Имя сервера'=$ev.Server; 'Где используется'=$ev.WhereUsed })
            }
        }
    }

    # Этап 5
    Write-ScanLog "ЭТАП 5/5: Слияние и сохранение результатов" -Level Header
    Merge-ScanResults -CsvPath $ResultPath -NewResults $results

    $total.Stop()
    Write-ScanLog "ГОТОВО. Общее время: $($total.Elapsed.ToString('hh\:mm\:ss'))" -Level Header
    Write-ScanLog "Файл результата: $ResultPath" -Level Success
}
#endregion

#region ===== Точка входа =====
Invoke-ServiceAccountScan `
    -DomainName         $DomainName `
    -OUUserServices     $OUUserServices `
    -OUServers          $OUServers `
    -ResultPath         $ResultUserAccounts `
    -LogDays            $LogRetentionDays `
    -BatchSize          $AccountBatchSize
#endregion