ProactiveRemediation_Detection.ps1

<# 
DOCFA_Java_Detection.ps1
Detection script per Intune Proactive Remediations

Obiettivo:
- Verificare se le chiavi di registro "fake Java 1.5" per DOCFA sono presenti
  e puntano a un file jvm.dll esistente.

Exit code:
- 0 = Configurazione OK, remediation NON necessaria
- 1 = Configurazione mancante o errata, remediation necessaria
#>

# ==========================
#   CONFIGURAZIONE LOG
# ==========================
$LogRoot           = "C:\ProgramData\IntuneLogs\DOCFA_Java"
$MaxLogSizeBytes   = 1MB   # ~1.048.576 byte
$RetentionDays     = 30

# Variabile globale per il file di log corrente
$script:LogFile = $null

function Initialize-Log {
    try {
        if (-not (Test-Path -LiteralPath $LogRoot)) {
            New-Item -Path $LogRoot -ItemType Directory -Force | Out-Null
        }

        # Pulizia log più vecchi di $RetentionDays
        $limitDate = (Get-Date).AddDays(-1 * $RetentionDays)
        Get-ChildItem -Path $LogRoot -Filter "DOCFA_Java_PR_*.log" -ErrorAction SilentlyContinue |
            Where-Object { $_.LastWriteTime -lt $limitDate } |
            Remove-Item -Force -ErrorAction SilentlyContinue

        # File log giornaliero
        $logName = "DOCFA_Java_PR_{0:yyyyMMdd}.log" -f (Get-Date)
        $script:LogFile = Join-Path $LogRoot $logName
    }
    catch {
        # In caso di errore nella gestione log, almeno scriviamo su output
        Write-Output "[$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')] [WARN] Impossibile inizializzare la gestione log: $($_.Exception.Message)"
    }
}

function Write-Log {
    param(
        [Parameter(Mandatory = $true)][ValidateSet("INFO","WARN","ERROR")] [string] $Level,
        [Parameter(Mandatory = $true)][string] $Message
    )

    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $line      = "$timestamp [$Level] $Message"

    # Log visibile in Intune
    Write-Host $line

    try {
        if (-not $script:LogFile) {
            Initialize-Log
        }

        if (-not (Test-Path -LiteralPath $script:LogFile)) {
            New-Item -Path $script:LogFile -ItemType File -Force | Out-Null
        }
        else {
            $size = (Get-Item -LiteralPath $script:LogFile).Length
            if ($size -gt $MaxLogSizeBytes) {
                $resetLine = "$timestamp [INFO] Log file ha superato 1 MB. Viene ricreato."
                Set-Content -Path $script:LogFile -Value $resetLine
            }
        }

        Add-Content -Path $script:LogFile -Value $line
    }
    catch {
        # Se la scrittura su file fallisce, ignoriamo ma almeno l'output Intune è già stato scritto
    }
}

# ==========================
#   LOG INIZIALE
# ==========================
Write-Log -Level INFO -Message "==== Avvio DOCFA_Java Detection ===="
Write-Log -Level INFO -Message "Computer: $env:COMPUTERNAME, Utente: $env:USERNAME"

# ==========================
#   LOGICA DI DETECTION
# ==========================

# Encapsulate detection in a function so it can be unit-tested.
function Get-DOCFAJavaDetectionStatus {
    param(
        [string] $RegKey = "HKLM:\\SOFTWARE\\WOW6432Node\\JavaSoft\\Java Runtime Environment\\1.5"
    )

    try {
        $regMissing = $false
        $runtimeLib = $null

        if (-not (Test-Path -LiteralPath $RegKey)) {
            Write-Log -Level WARN -Message "Chiave di registro non trovata: $RegKey"
            $regMissing = $true
        }
        else {
            $props = Get-ItemProperty -Path $RegKey -ErrorAction Stop
            $runtimeLib = $props.RuntimeLib
            if ([string]::IsNullOrWhiteSpace($runtimeLib)) {
                Write-Log -Level WARN -Message "Valore RuntimeLib mancante sotto $RegKey. Provo a rilevare jre/jvm dal filesystem."
                $runtimeLib = $null
            }
        }

        # Normalizza eventuali virgolette (se presente)
        if ($runtimeLib) { $runtimeLib = $runtimeLib.Trim('"') }

        # Se il valore punta direttamente al file jvm.dll
        if ($runtimeLib -and (Test-Path -LiteralPath $runtimeLib -PathType Leaf)) {
            Write-Log -Level INFO -Message "RuntimeLib valido (file): $runtimeLib"
            Write-Log -Level INFO -Message "Detection: configurazione OK, nessuna remediation necessaria."
            return 0
        }

        # Se il valore punta a una directory (es. la root della JRE), proviamo i possibili percorsi
        $candidates = @()
        if ($runtimeLib -and (Test-Path -LiteralPath $runtimeLib -PathType Container)) {
            $candidates += Join-Path $runtimeLib "bin\client\jvm.dll"
            $candidates += Join-Path $runtimeLib "bin\server\jvm.dll"
            $candidates += Join-Path $runtimeLib "jre\bin\client\jvm.dll"
            $candidates += Join-Path $runtimeLib "jre\bin\server\jvm.dll"
        }

        # Se RuntimeLib non è un path esistente, potremmo comunque provare a interpretarlo come una directory padre
        else {
            $parent = $null
            if ($runtimeLib) { $parent = Split-Path -Path $runtimeLib -Parent }
            if ($parent) {
                $candidates += Join-Path $parent "bin\client\jvm.dll"
                $candidates += Join-Path $parent "bin\server\jvm.dll"
            }
        }

        foreach ($cand in $candidates) {
            if (Test-Path -LiteralPath $cand -PathType Leaf) {
                $pf = $env:ProgramFiles
                $pf86 = ${env:ProgramFiles(x86)}

                if ($pf86 -and ($cand -like "$pf86*")) {
                    Write-Log -Level INFO -Message "Trovato jvm.dll in: $cand"
                    Write-Log -Level INFO -Message "Detection: configurazione OK, nessuna remediation necessaria."
                    return 0
                }
                elseif ($pf -and ($cand -like "$pf*")) {
                    Write-Log -Level WARN -Message "Rilevato jvm.dll in percorso 64-bit: $cand"
                    Write-Log -Level WARN -Message "È necessario installare una versione di Java x86."
                    return 1
                }
                else {
                    # Non è sotto Program Files (x86) né sotto Program Files: richiediamo Java x86 per coerenza
                    Write-Log -Level WARN -Message "Trovato jvm.dll in percorso non-x86: $cand"
                    Write-Log -Level WARN -Message "È necessario installare una versione di Java x86."
                    return 1
                }
            }
        }

        # Se non troviamo jvm.dll nei percorsi previsti, controlliamo se è presente solo una Java x64
        $pf = $env:ProgramFiles
        $pf86 = ${env:ProgramFiles(x86)}
        $found64 = $false
        $found86 = $false
        try {
            # Search exclusively for vendor installation paths (require vendor dir in path)
            $vendorDirRegex = '(?i)\\Program Files \(x86\)\\.*(java|eclipse adoptium|adoptopenjdk|zulu|amazon corretto|oracle|temurin|openjdk)\\'
            if ($pf86) {
                $found86 = (Get-ChildItem -Path $pf86 -Recurse -Filter 'jre.dll' -ErrorAction SilentlyContinue |
                            Where-Object { $_.FullName -match $vendorDirRegex } | Select-Object -First 1) -ne $null
                if (-not $found86) {
                    $found86 = (Get-ChildItem -Path $pf86 -Recurse -Filter 'jvm.dll' -ErrorAction SilentlyContinue |
                                Where-Object { $_.FullName -match $vendorDirRegex } | Select-Object -First 1) -ne $null
                }
            }
            if ($pf) {
                $found64 = (Get-ChildItem -Path $pf -Recurse -Filter 'jre.dll' -ErrorAction SilentlyContinue |
                            Where-Object { $_.FullName -match $vendorDirRegex } | Select-Object -First 1) -ne $null
                if (-not $found64) {
                    $found64 = (Get-ChildItem -Path $pf -Recurse -Filter 'jvm.dll' -ErrorAction SilentlyContinue |
                                Where-Object { $_.FullName -match $vendorDirRegex } | Select-Object -First 1) -ne $null
                }
            }
        }
        catch {
            # ignore errors while probing filesystem
        }

        # If we didn't find a candidate earlier, probe Program Files and Program Files (x86)
        $found64Path = $null
        $found86Path = $null
        try {
            if ($pf) {
                $found64Path = (Get-ChildItem -Path $pf -Recurse -Filter 'jvm.dll' -ErrorAction SilentlyContinue |
                                Where-Object { $_.FullName -match $vendorDirRegex } |
                                Select-Object -ExpandProperty FullName -First 1)
            }
            if ($pf86) {
                $found86Path = (Get-ChildItem -Path $pf86 -Recurse -Filter 'jvm.dll' -ErrorAction SilentlyContinue |
                                Where-Object { $_.FullName -match $vendorDirRegex } |
                                Select-Object -ExpandProperty FullName -First 1)
            }
        }
        catch {
            # ignore errors while probing filesystem
        }

        if ($found86Path) {
            Write-Log -Level INFO -Message "Rilevato jvm.dll x86 in: $found86Path"
            Write-Log -Level INFO -Message "Detection: configurazione OK, nessuna remediation necessaria."
            return 0
        }

        if ($found64Path -and -not $found86Path) {
            Write-Log -Level WARN -Message "Rilevato solo Java x64 ($pf); DOCFA richiede Java x86. Installare Java x86."
            return 1
        }

        Write-Log -Level WARN -Message "Il file jvm.dll indicato non esiste nei percorsi previsti (RuntimeLib: $runtimeLib)."
        Write-Log -Level INFO -Message "Detection: remediation richiesta (file jvm.dll inesistente)."
        return 1
    }
    catch {
        Write-Log -Level ERROR -Message "Errore durante la detection: $($_.Exception.Message)"
        return 1
    }
}

# Se lo script viene eseguito come file, usciamo con il codice restituito dalla funzione
if ($MyInvocation.InvocationName -eq $MyInvocation.MyCommand.Name) {
    $status = Get-DOCFAJavaDetectionStatus
    exit $status
}