Compare commits

..
11 Commits
Author SHA1 Message Date
Madzone 193fa40e3c update 2026-10-15 14:46:41 +02:00
Madzone 1b3e50cd32 function Get-VeeamConfig {
<#
        .SYNOPSIS
            Lädt zentrale Veeam Konfiguration aus JSON.
    #>

    param(

        [string]$Path = (Join-Path ( Split-Path $PSScriptRoot -Parent )"Config\VeeamConfig.json")

    )

    if(!(Test-Path $Path))
    {

        throw `

            "Konfigurationsdatei nicht gefunden: $Path"

    }

    $Content =

        Get-Content `

            -Path $Path `

            -Raw

    $Configuration =

        $Content |

        ConvertFrom-Json

    return $Configuration

}
2026-10-15 13:11:00 +02:00
Madzone 242c7c1253 Update 2026-10-15 13:00:30 +02:00
Madzone dd8d44da1e Update 2026-10-15 12:21:26 +02:00
Madzone c286614cfd Update 2026-10-13 15:13:34 +02:00
Madzone 3bc149a3e6 Update 2026-10-09 15:08:41 +02:00
Madzone ae8f403715 Update 2026-10-09 14:55:47 +02:00
Madzone 2500b1f354 Update 2026-10-09 14:50:28 +02:00
Madzone afbad0cb50 EJBCA Update 2026-09-25 21:14:21 +02:00
Madzone 3555432cd7 Update 2026-09-24 16:39:49 +02:00
Madzone 9da9ec58cc EJBCA 2026-09-24 16:31:15 +02:00
37 changed files with 5137 additions and 0 deletions
@@ -0,0 +1,2 @@
reports/
*.local.json
@@ -0,0 +1,22 @@
# Zuordnung verbindlicher Anforderungen – Entwurf
Nur in einer zugelassenen Umgebung mit freigegebenen Angaben ergänzen.
Für jede Sicherheitsdomäne einen eigenen geprüften Vorlagenstand führen.
NATO-/EU-Zuordnungen sind offen und werden nicht aus SCG-/STIG-Werten abgeleitet.
| Bereich | Umsetzung im Paket | Verbindliche Vorgabe / Stand | Nachweis / Ausnahme |
|---|---|---|---|
| Kontosperre und Entsperrzeit | AccountLockFailures=5, AccountUnlockTime=900 | Offen | JSON-Bericht |
| Passworthistorie | PasswordHistory=5 | Offen | JSON-Bericht |
| Passwortqualität | PasswordQualityControl laut baseline.json | Offen | JSON-Bericht; lokale Konten |
| SSH und ESXi Shell | Startmodus off, beendet | Offen | JSON-Bericht; Wartungsprozess ergänzen |
| Rollen, MFA, Notfallzugriff, Lockdown | Nicht automatisiert | Offen | Separater Prüfpunkt |
| Netz-/Sicherheitsdomänentrennung | Nicht automatisiert | Offen | Architekturprüfung |
| Zeitquelle, Remote-Logs, Aufbewahrung | Nicht automatisiert | Offen | Funktions-/Transportprüfung |
| Secure Boot, TPM, Verschlüsselung | Nicht automatisiert | Offen | Plattformprüfung |
| Zertifikate, Patch-/Buildstand | Build wird protokolliert | Offen | Separater Prüfpunkt |
| vCenter, VMs, vSAN, Backups | Nicht automatisiert | Offen | Separate Baselines |
Freigabeverantwortliche Stelle: offen
Freigegebener Vorlagenstand und Geltungsbereich: offen
Ausnahmen, Begründung, Ablaufdatum: offen
@@ -0,0 +1,108 @@
#Requires -Version 7.0
[CmdletBinding(SupportsShouldProcess, ConfirmImpact = 'High')]
param(
[Parameter(Mandatory)][string]$VCenter,
[Parameter(Mandatory)][string[]]$VMHostName,
[string]$BaselinePath = (Join-Path $PSScriptRoot 'baseline.json'),
[ValidateSet('Audit', 'Apply')][string]$Mode = 'Audit',
[string]$ReportDirectory = (Join-Path $PSScriptRoot 'reports')
)
Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'
$config = Get-Content -LiteralPath $BaselinePath -Raw | ConvertFrom-Json
if ($config.TargetVersion -ne '8.0.3') { throw 'Diese Version des Werkzeugs unterstützt ESXi 8.0.3.' }
if (@($config.AdvancedSettings).Count + @($config.Services).Count -eq 0) { throw 'Leere Baseline.' }
foreach ($entry in $config.AdvancedSettings) {
if ([string]::IsNullOrWhiteSpace($entry.Name) -or $null -eq $entry.Value) { throw 'Ungültiger Einstellungswert.' }
}
foreach ($entry in $config.Services) {
if ($entry.Policy -notin @('on', 'off', 'automatic') -or $entry.Running -isnot [bool]) { throw 'Ungültige Dienstkonfiguration.' }
}
foreach ($name in $VMHostName) {
if ([string]::IsNullOrWhiteSpace($name) -or $name -match '[*?\[\]]') { throw 'Nur explizite Hostnamen, keine Suchmuster angeben.' }
}
Import-Module VMware.VimAutomation.Core -ErrorAction Stop
# Existing authenticated session only; no embedded credentials or certificate bypass.
$sessions = @(foreach ($variableName in @('DefaultVIServers', 'DefaultVIServer')) {
$variable = Get-Variable -Name $variableName -Scope Global -ErrorAction SilentlyContinue
if ($null -ne $variable) { $variable.Value }
})
$servers = @($sessions | Where-Object { $_.Name -eq $VCenter -and $_.IsConnected } | Sort-Object -Property Name -Unique)
if ($servers.Count -ne 1) { throw 'Zuerst mit Connect-VIServer genau eine Sitzung zum angegebenen vCenter herstellen.' }
$server = $servers[0]
if ([version]$server.Version -lt [version]'8.0' -or [version]$server.Version -ge [version]'9.0') { throw 'vCenter 8 erforderlich.' }
# Resolve and validate every target before making any change.
$targets = @(foreach ($name in ($VMHostName | Select-Object -Unique)) {
$found = @(Get-VMHost -Server $server -Name $name | Where-Object { $_.Name -eq $name })
if ($found.Count -ne 1) { throw "Host nicht eindeutig gefunden: $name" }
if ($found[0].Version -ne $config.TargetVersion) { throw "Nicht unterstützte ESXi-Version auf $name" }
if ([string]$found[0].ConnectionState -notin @('Connected', 'Maintenance')) { throw "Host nicht erreichbar: $name" }
$found[0]
})
$runId = '{0}-{1}' -f (Get-Date -Format 'yyyyMMdd-HHmmss'), ([guid]::NewGuid().ToString('N').Substring(0,8))
# Reports are intentionally also written in Audit and -WhatIf modes.
$null = [IO.Directory]::CreateDirectory($ReportDirectory)
$reportPath = Join-Path $ReportDirectory "$runId.json"
$rows = [Collections.Generic.List[object]]::new()
$report = [ordered]@{
StartedUtc = [DateTime]::UtcNow.ToString('o'); VCenter = $VCenter; Mode = $Mode
Baseline = $config; BaselineSha256 = (Get-FileHash -LiteralPath $BaselinePath -Algorithm SHA256).Hash
Results = $rows
}
function Save-Report { $report | ConvertTo-Json -Depth 15 | Set-Content -LiteralPath $reportPath -Encoding utf8 -WhatIf:$false }
Save-Report
foreach ($target in $targets) {
$controls = @(
foreach ($entry in $config.AdvancedSettings) { [pscustomobject]@{ Kind = 'Advanced'; Entry = $entry } }
foreach ($entry in $config.Services) { [pscustomobject]@{ Kind = 'Service'; Entry = $entry } }
)
foreach ($control in $controls) {
$entry = $control.Entry
$key = if ($control.Kind -eq 'Advanced') { $entry.Name } else { $entry.Key }
$desired = if ($control.Kind -eq 'Advanced') { [string]$entry.Value } else { "$($entry.Policy)/$($entry.Running)" }
$row = [pscustomobject]@{
Host = $target.Name; Build = $target.Build; Kind = $control.Kind; Setting = $key
Control = $entry.Control; Before = $null; Desired = $desired; After = $null
Status = 'Pending'; Error = $null
}
$rows.Add($row)
try {
if ($control.Kind -eq 'Advanced') {
$items = @(Get-AdvancedSetting -Entity $target -Name $key | Where-Object Name -EQ $key)
if ($items.Count -ne 1) { throw 'Einstellung fehlt oder ist nicht eindeutig; wird nicht neu angelegt.' }
$item = $items[0]
$row.Before = [string]$item.Value
} else {
$items = @(Get-VMHostService -VMHost $target | Where-Object Key -EQ $key)
if ($items.Count -ne 1) { throw 'Dienst fehlt oder ist nicht eindeutig.' }
$item = $items[0]
$row.Before = "$($item.Policy)/$($item.Running)"
}
$row.After = $row.Before
$row.Status = if ($row.Before -ceq $desired) { 'Match' } else { 'Drift' }
if ($row.Status -eq 'Drift' -and $Mode -eq 'Apply') {
if ($PSCmdlet.ShouldProcess("$($target.Name): $key", "$($row.Before) -> $desired")) {
$row.Status = 'Applying'
Save-Report # Persist original value before any remote mutation.
if ($control.Kind -eq 'Advanced') {
$null = Set-AdvancedSetting -AdvancedSetting $item -Value $entry.Value -Confirm:$false
$row.After = [string](Get-AdvancedSetting -Entity $target -Name $key).Value
} else {
if ($item.Policy -ne $entry.Policy) { $null = Set-VMHostService -HostService $item -Policy $entry.Policy -Confirm:$false }
if ($item.Running -ne $entry.Running) {
if ($entry.Running) { $null = Start-VMHostService -HostService $item -Confirm:$false }
else { $null = Stop-VMHostService -HostService $item -Confirm:$false }
}
$fresh = Get-VMHostService -VMHost $target | Where-Object Key -EQ $key
$row.After = "$($fresh.Policy)/$($fresh.Running)"
}
$row.Status = if ($row.After -ceq $desired) { 'AppliedVerified' } else { 'VerificationFailed' }
} else { $row.Status = 'Skipped' }
}
} catch { $row.Status = 'Error'; $row.Error = $_.Exception.Message; $row.After = $null }
Save-Report
}
}
$rows | Format-Table Host, Setting, Before, Desired, After, Status -AutoSize | Out-Host
Write-Host "Bericht: $reportPath"
if (@($rows | Where-Object Status -In @('Error','VerificationFailed')).Count) { throw 'Prüfung/Anwendung unvollständig. Bericht beachten; Teiländerungen sind möglich.' }
+111
View File
@@ -0,0 +1,111 @@
# Wiederverwendbare ESXi-Sicherheitsvorlage
Entwurf für ESXi **8.0.3** und vCenter **8**. Enthält sechs automatisierte
Kontrollen als erweiterbare Startbasis, keine vollständige VMware-Härtung und
keine NATO-/EU-Freigabe. Die vier Advanced Settings stammen aus dem öffentlichen
VMware Security Configuration Guide für 8.0.3; SSH und ESXi Shell werden als
lokale Entwurfsentscheidung deaktiviert. Diese Werte sind keine behaupteten
NATO-/EU-Vorgaben. Es werden keine vCenter-Einstellungen geändert.
## Verwendung
PowerShell 7 und das Modul VMware.VimAutomation.Core werden vorausgesetzt.
In einer zugelassenen Administrationsumgebung ausführen. Zugangsdaten bleiben
in der interaktiven PowerCLI-Anmeldung; Zertifikatsprüfung nicht deaktivieren.
1. `baseline.json` pro freigegebenem Einsatzzweck kopieren und versionieren.
Anforderungen und Ausnahmen in `Anforderungsmatrix.md` ergänzen.
2. Mit vCenter verbinden und zunächst einen expliziten Testhost prüfen.
3. Änderungen simulieren, dann auf dem Testhost anwenden und erneut prüfen.
4. Erst danach denselben Vorlagenstand auf weitere passende Hosts anwenden.
```powershell
Connect-VIServer -Server 'vcenter.example.internal'
# Standard: ausschließlich prüfen
./Invoke-EsxiBaseline.ps1 -VCenter 'vcenter.example.internal' `
-VMHostName 'esxi01.example.internal'
# Änderungen anzeigen, ohne sie auf dem Host auszuführen
./Invoke-EsxiBaseline.ps1 -VCenter 'vcenter.example.internal' `
-VMHostName 'esxi01.example.internal' -Mode Apply -WhatIf
# Anwenden: PowerShell fragt pro abweichender Einstellung nach
./Invoke-EsxiBaseline.ps1 -VCenter 'vcenter.example.internal' `
-VMHostName 'esxi01.example.internal' -Mode Apply
# Eigene, bereits geprüfte Vorlage und mehrere explizite Hosts
./Invoke-EsxiBaseline.ps1 -VCenter 'vcenter.example.internal' `
-VMHostName 'esxi01.example.internal','esxi02.example.internal' `
-BaselinePath './standort-baseline.json'
```
`-Confirm:$false` ermöglicht später einen bewusst unbeaufsichtigten Apply-Lauf.
Die Standardaktion bleibt Audit. Audit und WhatIf schreiben lokale Berichte.
Berichte unter `reports/` enthalten Baseline, Hash, Build, Vorher-/Nachherwerte
und Einzelstatus. `Match` bedeutet nur Übereinstimmung mit dieser Vorlage,
keine Gesamt-Konformität. `Drift` ist eine Abweichung, `Skipped` wurde nicht
angewendet. Fehler und fehlgeschlagene Nachprüfungen führen am Ende zu einem
terminierenden Fehler. Abweichungen im Audit sind normale Berichtsergebnisse.
Bei Fehlern können Teiländerungen vorliegen; es gibt keinen automatischen Rollback.
Vorherwerte werden vor jeder Änderung gespeichert. Eine Rücknahme erfolgt
gezielt mit diesen Werten und anschließender erneuter Prüfung.
Passwortregeln können Integrationen beeinträchtigen; Kontosperren können auch
berechtigte Zugriffe blockieren. SSH-/Shell-Abschaltung beeinflusst Wartungswege.
Vor Apply einen funktionierenden administrativen Wiederherstellungsweg prüfen.
Berichte und standortspezifische Vorlagen nur in der dafür zugelassenen Umgebung
speichern; nicht in öffentliche Repositories übernehmen.
## Daraus ein natives Hostprofil erstellen
Nach erfolgreicher Einrichtung und Prüfung des ersten Hosts kann vCenter das
native Profil extrahieren. Host-Profile-Funktion und Lizenzberechtigung müssen
vorhanden sein. Beispiel in derselben PowerCLI-Sitzung:
```powershell
$vc = $global:DefaultVIServers | Where-Object Name -EQ 'vcenter.example.internal'
$reference = Get-VMHost -Server $vc -Name 'esxi01.example.internal'
New-VMHostProfile -Server $vc -Name 'ESXi803-Freigegebene-Basis-v1' `
-ReferenceHost $reference
```
Das extrahierte Profil umfasst auch andere Einstellungen des Referenzhosts.
Vor Zuordnung zu weiteren Hosts im vSphere Client den Profilumfang bearbeiten,
hostabhängige Netzwerk-/Storage-Werte prüfen und Hostanpassungen festlegen.
Dieses Paket verteilt oder remediert native Hostprofile nicht automatisch.
## Offene Bereiche
Netztrennung, Lockdown und Notfallzugang, Rollen/MFA, NTP, zentrale Protokollierung
mit geschütztem Transport, Zertifikate, Secure Boot/TPM, Patchstand, VM-/vSAN-
Härtung, Sicherung/Wiederherstellung und vCenter-Härtung müssen separat bewertet
werden. Insbesondere ist die Versionsnummer 8.0.3 kein Nachweis eines aktuellen
Patchstands. Anforderungen für NATO und EU sowie unterschiedliche Einstufungen
lokal zuordnen; keine erfundenen SECRET-/RESTRICTED-Parameter verwenden.
## Quellen
Abgeglichen am 05.10.2026; die Online-Baseline kann sich ändern.
- [Offizieller VMware SCG 8 mit Kontrollen und PowerCLI-Beispielen](https://github.com/vmware/vcf-security-and-compliance-guidelines/tree/main/security-configuration-hardening-guide/vsphere/8.0)
- [New-VMHostProfile](https://developer.broadcom.com/powercli/latest/vmware.vimautomation.core/commands/new-vmhostprofile/)
- [Set-VMHostService](https://developer.broadcom.com/powercli/latest/vmware.vimautomation.core/commands/set-vmhostservice)
## Prüfung dieses Pakets
PowerShell-Syntax und simulierte Audit-/Apply-/WhatIf-/Fehlerpfade lokal prüfen.
Ein Integrationstest gegen echtes vCenter/ESXi ist vor produktivem Einsatz nötig.
Offline-Test in einem separaten PowerShell-Prozess starten (verwendet simulierte
PowerCLI-Befehle und schreibt Testberichte ins temporäre Verzeichnis):
```powershell
pwsh -NoProfile -File ./Tests/Test-Offline.ps1
```
Geprüft: Audit ohne Änderungen, WhatIf ohne Änderungen, Apply mit Nachprüfung,
wiederholtes Apply ohne erneute Änderungen, Ablehnung falscher ESXi-Versionen
und Fehlerbericht bei fehlenden Einstellungen. Diese Tests ersetzen keinen
Integrationstest auf einem ESXi-Testhost.
@@ -0,0 +1,62 @@
# Offline behavioral tests; no VMware module, credentials or remote connection.
$ErrorActionPreference = 'Stop'
$scriptPath = Join-Path $PSScriptRoot '../Invoke-EsxiBaseline.ps1'
$baselinePath = Join-Path $PSScriptRoot '../baseline.json'
$testRoot = Join-Path ([IO.Path]::GetTempPath()) ('esxi-baseline-test-' + [guid]::NewGuid())
function Import-Module { param($Name, $ErrorAction) }
$global:DefaultVIServers = @([pscustomobject]@{Name='test-vc'; IsConnected=$true; Version='8.0.3'})
$global:DefaultVIServer = $global:DefaultVIServers[0]
function Get-VMHost { param($Server,$Name)
[pscustomobject]@{Name=$Name; Version=$global:baselineTestVersion; Build='mock'; ConnectionState='Connected'}
}
function Get-AdvancedSetting { param($Entity,$Name)
if ($global:baselineTestMissing -eq $Name) { return }
[pscustomobject]@{Name=$Name;Value=$global:baselineTestValues[$Name]}
}
function Set-AdvancedSetting { param($AdvancedSetting,$Value,[switch]$Confirm)
$global:baselineTestWrites++; $global:baselineTestValues[$AdvancedSetting.Name]=$Value
}
function Get-VMHostService { param($VMHost) $global:baselineTestServices }
function Set-VMHostService { param($HostService,$Policy,[switch]$Confirm) $global:baselineTestWrites++; $HostService.Policy=$Policy }
function Stop-VMHostService { param($HostService,[switch]$Confirm) $global:baselineTestWrites++; $HostService.Running=$false }
function Start-VMHostService { param($HostService,[switch]$Confirm) $global:baselineTestWrites++; $HostService.Running=$true }
function Reset-State {
$global:baselineTestWrites=0; $global:baselineTestVersion='8.0.3'; $global:baselineTestMissing=''
$global:baselineTestValues=@{}
(Get-Content $baselinePath -Raw | ConvertFrom-Json).AdvancedSettings | ForEach-Object { $global:baselineTestValues[$_.Name]='different' }
$global:baselineTestServices=@('TSM','TSM-SSH') | ForEach-Object { [pscustomobject]@{Key=$_; Policy='on'; Running=$true} }
}
function Assert($condition,$message) { if (-not $condition) { throw $message } }
function Run-Case($name,$mode,[switch]$Simulation) {
$parameters=@{VCenter='test-vc';VMHostName=@('test-esxi');Mode=$mode;ReportDirectory=(Join-Path $testRoot $name);Confirm=$false}
if ($Simulation) { $parameters.WhatIf=$true }
& $scriptPath @parameters
Get-Content (Get-ChildItem $parameters.ReportDirectory -Filter '*.json')[0].FullName -Raw | ConvertFrom-Json
}
Reset-State
$r=Run-Case 'audit' 'Audit'
Assert ($global:baselineTestWrites -eq 0) 'Audit mutated host'
Assert (@($r.Results | Where-Object Status -EQ Drift).Count -eq 6) 'Audit missed drift'
$r=Run-Case 'whatif' 'Apply' -Simulation
Assert ($global:baselineTestWrites -eq 0) 'WhatIf mutated host'
Assert (@($r.Results | Where-Object Status -EQ Skipped).Count -eq 6) 'WhatIf results incorrect'
$r=Run-Case 'apply' 'Apply'
Assert ($global:baselineTestWrites -eq 8) 'Unexpected mutation count'
Assert (@($r.Results | Where-Object Status -EQ AppliedVerified).Count -eq 6) 'Apply not verified'
$previousWrites=$global:baselineTestWrites
$r=Run-Case 'repeat' 'Apply'
Assert ($global:baselineTestWrites -eq $previousWrites) 'Repeated apply not idempotent'
Assert (@($r.Results | Where-Object Status -EQ Match).Count -eq 6) 'Repeat did not match'
Reset-State
$global:baselineTestVersion='7.0.3'
$failed=$false
try { $null=Run-Case 'version' 'Apply' } catch { $failed=$true }
Assert ($failed -and $global:baselineTestWrites -eq 0) 'Version gate failed'
Reset-State
$global:baselineTestMissing='Security.PasswordHistory'
$failed=$false
try { $null=Run-Case 'missing' 'Audit' } catch { $failed=$true }
Assert ($failed -and $global:baselineTestWrites -eq 0) 'Missing setting did not fail safely'
$r=Get-Content (Get-ChildItem (Join-Path $testRoot 'missing') -Filter '*.json')[0].FullName -Raw | ConvertFrom-Json
Assert (@($r.Results | Where-Object Status -EQ Error).Count -eq 1) 'Missing setting not reported'
Write-Host 'PASS: Audit, WhatIf, Apply, repeat, version gate, missing-setting report.'
@@ -0,0 +1,17 @@
{
"Name": "ESXi-8.0.3-Startbaseline",
"Revision": "0.1-draft",
"TargetVersion": "8.0.3",
"ClassificationMapping": "Offen: freigegebene NATO-/EU-Vorgaben lokal zuordnen",
"Source": "https://github.com/vmware/vcf-security-and-compliance-guidelines/tree/main/security-configuration-hardening-guide/vsphere/8.0",
"AdvancedSettings": [
{ "Name": "Security.AccountUnlockTime", "Value": 900, "Control": "esxi-8.account-auto-unlock-time" },
{ "Name": "Security.AccountLockFailures", "Value": 5, "Control": "esxi-8.account-lockout" },
{ "Name": "Security.PasswordHistory", "Value": 5, "Control": "esxi-8.account-password-history" },
{ "Name": "Security.PasswordQualityControl", "Value": "similar=deny retry=3 min=disabled,disabled,disabled,disabled,15 max=64", "Control": "esxi-8.account-password-policies" }
],
"Services": [
{ "Key": "TSM-SSH", "Policy": "off", "Running": false, "Control": "LOCAL-disable-ssh" },
{ "Key": "TSM", "Policy": "off", "Running": false, "Control": "LOCAL-disable-shell" }
]
}
+172
View File
@@ -0,0 +1,172 @@
# EJBCA Issuing: automatisierte Migration von H2 nach PostgreSQL
## Start
Die Datei `migrate_ejbca_issuing.py` auf den Docker-Host nach
`/root/migrate_ejbca_issuing.py` hochladen. Nicht den Quelltext aus einem Chat
in das Terminal kopieren. Auf dem Docker-Host als root ausführen:
```bash
python3 /root/migrate_ejbca_issuing.py
```
Die Issuing-CA wird nach den Vorprüfungen gestoppt und bleibt bis zum anschließenden
Portainer-Update außer Betrieb. Die Root-CA wird weder gestoppt noch verändert.
Der Lauf kann mehrere Minuten dauern. Keine zweite Instanz des Skripts starten.
## Voraussetzungen und festgelegter Umfang
- Linux-Docker-Host mit Python ab 3.9; keine zusätzlichen Python-Pakete nötig.
- Quelle: Container `ejbca_issuing`, ein Volume `ejbca_issuing_data` unter
`/mnt/persistent`, Netzwerk `cert-net`, keine veröffentlichten Host-Ports.
- Das bereits geprüfte EJBCA-Image wird über seinen Digest festgelegt:
`keyfactor/ejbca-ce@sha256:183b86af44b9b13e7cc8912c868f635aeb8dba6bf056ccbd4683b17626964d0a`.
- Die konfigurierte H2-Datei muss direkt unter `/mnt/persistent` liegen.
- Der H2-Treiber muss dem bereits geprüften H2 2.2.224 entsprechen.
- Das Skript ist für die gezeigte Konfiguration mit Software-CryptoTokens gebaut.
Bei inaktiven Tokens, HSMs, unbekannten Datentypen, anderen Mounts oder
nicht unterstützten Containeroptionen bricht es ab.
- Es benötigt ausreichend freien Speicher für die Volumesicherung, zwei
Anwendungskopien, H2-Arbeitskopien und zwei PostgreSQL-Volumes.
- PostgreSQL 17 und Java 17 werden bei Bedarf vor der Ausfallzeit heruntergeladen.
## Bereits vorhandene Issuing-Sicherung
Vor dem Stoppen prüft das Skript die im Chat bestätigten Sicherungen:
- `/root/ejbca-backup/ejbca_issuing.tar.gz`
- `/mnt/HEIMLAN/001-Zertifikate/EJBCA-Backup/2026-09-24/ejbca_issuing.tar.gz`
Mindestens eine Kopie muss erreichbar sein. Jede vorhandene Kopie wird anhand
der damaligen SHA-256-Prüfsummen des Archivs und der enthaltenen H2-Datei
geprüft. Bei einer Abweichung bricht das Skript vor dem Stoppen ab. Die Archive
werden ausschließlich gelesen, niemals überschrieben oder entpackt.
Zusätzlich wird nach dem Stoppen ein aktueller Stand gesichert und für die
Migration verwendet. Issuing lief seit der alten Sicherung weiter; deshalb
wird kein älterer Datenstand zurückgespielt. Ein Unterschied der H2-Dateien
wird protokolliert und ist kein Fehler. Er beweist allein keine fachliche
Datenänderung. `existing-backups.json` und `backup-comparison.json` dokumentieren
die Prüfung im neuen Arbeitsverzeichnis.
## Ablauf
1. Containerkonfiguration und Image prüfen, JDBC-Treiber und SQL-Skripte aus dem
vorhandenen Issuing-Container extrahieren, Java-Helfer kompilieren.
2. Issuing stoppen, vollständiges Originalvolume als TAR sichern, H2-Datei
separat kopieren und beide Kopien über SHA-256 vergleichen.
3. H2 Recover ausschließlich auf einer Arbeitskopie ausführen. Alle im Dump
gefundenen binären Hilfsspalten von VARCHAR auf VARBINARY korrigieren.
Der ursprüngliche Dump bleibt erhalten. Ein neues temporäres H2-Passwort
wird ausschließlich für die Rekonstruktion verwendet.
4. Neue H2-Datenbank erzeugen. Alle nichtleeren Tabellenzahlen mit den
Recover-INSERTs und alle Binärwerte einschließlich ihrer Längen und
SHA-256-Werte mit den Hexliteralen im ursprünglichen Dump vergleichen.
5. Neue Testdatenbank in einem internen Netzwerk erstellen. Den aus dem
Root-Verfahren abgeleiteten JDBC-Helper ausführen. Tabellen-/Zeilenzahlen
werden aus der Issuing-Quelle ermittelt. Spaltenzuordnung, Datentypen,
Fremdschlüssel, Leerheit, vollständige Werte und Rowcounts werden geprüft.
Inserts erfolgen in einer Transaktion. Der Helper kennt ausschließlich
`ejbca_issuing_migration_test_db`.
6. Alle 44 PostgreSQL-Indizes vor dem ersten EJBCA-Teststart anlegen. Die vier
DELETE-Befehle im Originalskript werden durch eine Abbruchprüfung ersetzt.
7. Testanwendung mit kopiertem Volume, erhaltenen Verschlüsselungs-/CLI-Einstellungen,
ohne veröffentlichte Ports und in einem internen Netzwerk starten.
Bereitschaft, Fehlerlogs, CA-Liste, Tokenstatus und alle erkannten
Software-Schlüsselpaare prüfen. Danach Testanwendung stoppen.
8. Ausschließlich das vom Skript neu angelegte Testschema erneut aufbauen und
die ursprünglichen Issuing-Daten plus Indizes importieren. Somit werden keine
beim Teststart erzeugten Zertifikate oder anderen Änderungen übernommen.
9. Sauberen Dump erstellen. Neue endgültige Datenbank `ejbca_issuing_db` in
`ejbca-issuing-db-net` erstellen, Dump transaktional wiederherstellen und
Tabellenzahlen, vollständige Zeilen-Digests sowie Indizes vergleichen.
10. Eigenes dauerhaftes App-Volume aus dem gestoppten Original kopieren und die
fertige Compose-Datei für den bestehenden Portainer-Stack erzeugen.
Das Skript exportiert keine privaten Schlüssel als separate Dateien und stellt
keine Zertifikate per CLI aus. Der EJBCA-Teststart selbst kann ein Serverzertifikat
in seiner isolierten Testdatenbank anlegen. Sicherungen und Datenbank-Dumps
enthalten selbstverständlich vertrauliche CA-Daten.
## Ergebnis
Am Ende zeigt das Skript das neu generierte Passwort für **Issuing-PostgreSQL**
und die vollständige Compose-Konfiguration direkt im lokalen Terminal an.
Dieses Passwort ist nicht das alte H2-Passwort, kein Root-CA-Passwort und kein
CryptoToken-PIN. Vorhandene Schlüssel-/Verschlüsselungspasswörter werden nicht
geändert. Die Compose-Datei enthält das neue DB-Passwort bereits; keine zusätzliche
Portainer-Variable ist erforderlich.
Alle Dateien liegen in einem neuen, nur für root zugänglichen Verzeichnis:
```text
/root/ejbca-issuing-migration/run-DATUM-UHRZEIT-ZUFALL/
```
Wichtige Dateien:
- `docker-compose.issuing.yml`: fertige Konfiguration für den vorhandenen
Portainer-Stack `ejbca-issuing`.
- `credentials.private.json`: erzeugte H2-, Test- und endgültige DB-Zugangsdaten.
- `original.inspect.json`, `original-volume.tar`, `original.mv.db` und
`original.sha256`: Originalkonfiguration und geprüfte Sicherungen.
- `recover/ejbcadb.h2.sql`: ursprünglicher Recover-Dump.
- `restored/`: binärsicher rekonstruierte H2-Quelle; SQL enthält ein temporäres Passwort.
- `source-inventory.tsv`, `migration.log`, `key-tests.log`, `report.json`:
Prüfresultate ohne vollständige Nutzdaten.
- `issuing-clean.dump` und `.sha256`: sauberer Export vor Anwendungsstart.
- `verify-after-deploy.sh`: Bereitschafts- und Schlüsseltests nach dem Deployment.
- `docker-compose.database-reference.yml`: Dokumentation des bereits vom Skript
gestarteten DB-Containers. Nicht als zusätzlichen Stack deployen, solange dieser
Container existiert.
Das Skript ersetzt/deployt den bestehenden Issuing-Container **nicht automatisch**.
Die endgültige PostgreSQL-Datenbank läuft bereits mit einem benannten Volume und
Restart-Policy `unless-stopped`. Die Testanwendung ist gestoppt.
## Portainer-Update und Abschluss
1. Nach erfolgreichem Skriptende in Portainer den bestehenden Stack
`ejbca-issuing` öffnen.
2. Den Editorinhalt durch `docker-compose.issuing.yml` ersetzen.
3. Stack aktualisieren. Das festgelegte Image bleibt die getestete Version.
4. Nach etwa 90 Sekunden den erzeugten Prüfblock ausführen:
```bash
sh /root/ejbca-issuing-migration/run-DATUM-UHRZEIT-ZUFALL/verify-after-deploy.sh
```
5. In der gewohnten Adminoberfläche Issuing-CA und Profile kontrollieren.
6. Nach erfolgreichem Abschluss einen aktuellen PostgreSQL-Dump sichern und
regelmäßige Datenbankbackups vorsehen. Alte H2-Sicherungen vorerst behalten.
Bestehende TLS-/Adminzugangseinstellungen werden übernommen. Insbesondere wird
`TLS_SETUP_ENABLED=simple`, falls vorhanden, durch dieses Migrationsskript nicht
auf Clientzertifikatsanmeldung umgestellt.
## Bei einem Fehler
Das Skript bricht ab und stoppt seine eigene Testanwendung, soweit sie bereits
angelegt wurde. Es löscht keine vorhandenen Container/Volumes automatisch.
Nach begonnenen Arbeiten nicht blind erneut ausführen: vorhandene Zielnamen
führen absichtlich zum Abbruch.
Die ursprüngliche Issuing-Compose-Konfiguration und das ursprüngliche H2-Volume
bleiben unverändert. Die ursprüngliche Anwendung kann bereits gestoppt sein.
Solange noch kein Portainer-Update erfolgt ist und niemand die Originalkonfiguration
geändert hat, kann sie bei Bedarf mit `docker start ejbca_issuing` wieder auf dem
alten H2-Stand laufen. Danach ist eine frühere Migrationskopie möglicherweise
veraltet und darf nicht ohne neuen Abgleich eingesetzt werden.
Zur Diagnose zunächst nur die Abbruchmeldung und `progress.log` weitergeben.
`private-errors.log`, `test-start.private.log`, JSON-Konfigurationen, SQL-Dumps und
Compose-Dateien können Geheimnisse enthalten; nicht ungeschwärzt posten.
## Prüfstatus dieses Lieferstands
Python-Syntax und lokale Tests für SQL-Lexer, Binärkorrektur, Abbruchfälle,
Indexkonvertierung und Compose-Werte wurden geprüft. Der JDBC-Migrationscode
ist aus dem auf deinem Host ausgeführten Root-Helper abgeleitet; das Original
bleibt unverändert. Ein vollständiger Docker-/EJBCA-Durchlauf wurde in dieser
Arbeitsumgebung nicht ausgeführt. Die Java-Helfer werden auf dem Docker-Host
vor dem Stoppen der Issuing-Anwendung kompiliert.
+97
View File
@@ -0,0 +1,97 @@
#!/usr/bin/env python3
"""Finish only the verified Issuing migration run; never deploy the app."""
import importlib.util
import json
import os
from pathlib import Path
import subprocess
import sys
RUN = Path('/root/ejbca-issuing-migration/run-20260924-163240-49d64d')
DUMP_HASH = '23e989f0c39ee7abc1491833cb37b61827029091e8b5f8aaa8148251f74f83be'
def main():
if os.geteuid() != 0:
raise RuntimeError('Als root auf dem Docker-Host ausfuehren.')
os.umask(0o077)
spec = importlib.util.spec_from_file_location('migration', '/root/migrate_ejbca_issuing.py')
m = importlib.util.module_from_spec(spec)
spec.loader.exec_module(m)
m.WORK = RUN
m.check(m.APP == 'ejbca_issuing' and m.FINAL_DB == 'ejbca_issuing_db', 'Unerwartete Zielnamen.')
for app in (m.APP, m.TEST_APP):
m.check(m.inspect(app)['State']['Status'] == 'exited', app + ' muss gestoppt sein.')
original = json.loads((RUN / 'original.inspect.json').read_text())
current = m.inspect(m.APP)
for key in ('Id', 'Image', 'Config', 'Mounts', 'HostConfig'):
m.check(current[key] == original[key], 'Originalkonfiguration hat sich geaendert: ' + key)
m.check(current['Image'] == m.EXPECTED_IMAGE, 'Unerwartetes EJBCA-Image.')
image = json.loads(m.docker('image', 'inspect', m.EXPECTED_IMAGE))[0]
m.check(m.EJBCA_IMAGE in image.get('RepoDigests', []), 'EJBCA-Digest fehlt.')
dump = RUN / 'issuing-clean.dump'
m.check(m.digest(dump) == DUMP_HASH, 'Pruefsumme des sauberen Exports stimmt nicht.')
expected = {t: tuple(v) for t, v in json.loads((RUN / 'clean-counts-and-digests.json').read_text()).items()}
m.check(len(expected) == 37 and sum(v[0] for v in expected.values()) == 129,
'Erwartetes Inventar stimmt nicht.')
m.check(expected['userdatasourcedata'][0] == 0, 'userdatasourcedata muss leer sein.')
m.check(m.snapshot(m.TEST_DB) == expected, 'Saubere Testdatenbank wurde zwischenzeitlich veraendert.')
for line in (RUN / 'original.sha256').read_text().splitlines():
checksum, name = line.split()
m.check(name in ('original.mv.db', 'original-volume.tar'), 'Unerwarteter Sicherungspfad.')
m.check(m.digest(RUN / name) == checksum, 'Originalsicherung stimmt nicht: ' + name)
url = m.envmap(current['Config'])['DATABASE_JDBC_URL']
m.check(url.startswith('jdbc:h2:/mnt/persistent/'), 'Quelle ist nicht mehr H2.')
dbfile = url.split(';')[0].removeprefix('jdbc:h2:') + '.mv.db'
checkfile = RUN / 'original-current-check.mv.db'
m.docker('cp', m.APP + ':' + dbfile, str(checkfile))
checkfile.chmod(0o600)
m.check(m.digest(checkfile) == m.digest(RUN / 'original.mv.db'), 'Original-H2 wurde seit der Sicherung veraendert.')
credentials = json.loads((RUN / 'credentials.private.json').read_text())
m.FINAL_PASSWORD = credentials['issuing_pg']
m.check(bool(m.FINAL_PASSWORD), 'Zielpasswort fehlt.')
# Reuse exactly the PostgreSQL image used by the verified test database.
pgimage = json.loads(m.docker('image', 'inspect', m.inspect(m.TEST_DB)['Image']))[0]
m.PG_PIN = next((d for d in pgimage.get('RepoDigests', []) if d.startswith('postgres@')), None)
m.check(m.PG_PIN, 'PostgreSQL-Image-Digest fehlt.')
m.absent('container', [m.FINAL_DB])
m.absent('network', [m.FINAL_NETWORK])
m.absent('volume', [m.FINAL_DB_VOLUME, m.FINAL_APP_VOLUME])
for name in ('docker-compose.issuing.yml', 'docker-compose.database-reference.yml'):
m.check(not (RUN / name).exists(), 'Compose-Datei existiert bereits: ' + name)
print('Vorpruefungen erfolgreich. Neues Issuing-PostgreSQL-Ziel wird erstellt.', flush=True)
m.docker('network', 'create', '--internal', m.FINAL_NETWORK)
m.create_pg(m.FINAL_DB, m.FINAL_DB_VOLUME, m.FINAL_NETWORK, m.FINAL_PASSWORD)
m.docker('exec', '-i', m.FINAL_DB, 'pg_restore', '-U', 'ejbca', '-d', 'ejbcadb',
'--exit-on-error', '--single-transaction', data=dump.read_bytes(), timeout=3600)
m.check(m.snapshot(m.FINAL_DB) == expected, 'Endgueltiges Ziel weicht vom sauberen Stand ab.')
m.check(m.inspect(m.APP)['State']['Status'] == 'exited', 'Original-App wurde gestartet.')
m.copy_volume(m.FINAL_APP_VOLUME)
m.write_compose(original, m.envmap(image['Config']))
if subprocess.run(['docker', 'compose', 'version'], stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL).returncode == 0:
m.docker('compose', '-f', str(RUN / 'docker-compose.issuing.yml'), 'config', '--quiet')
(RUN / 'finish-report.json').write_text(json.dumps({
'dump_sha256': DUMP_HASH, 'rows': 129, 'tables': 37, 'valid_additional_indexes': 44,
'app_deployed': False, 'offline_token': 'ImportedCryptoToken264870329',
'offline_token_key_tested': False,
'active_token_key_tests': '5 successful tests reported by operator in chat'
}, indent=2))
print('OK: Ziel wiederhergestellt und vollstaendig mit dem sauberen Stand verglichen.')
print('Die Issuing-App bleibt gestoppt. Deployment erfolgt anschliessend in Portainer.')
print('\nISSUING-POSTGRESQL-PASSWORT (vertraulich):\n' + m.FINAL_PASSWORD)
print('\nCOMPOSE FUER DEN BESTEHENDEN STACK ejbca-issuing:\n')
print((RUN / 'docker-compose.issuing.yml').read_text())
print('Die database-reference-Datei NICHT als weiteren Stack deployen.')
print('Passwort und Compose nicht in den Chat posten. Ergebnisverzeichnis: ' + str(RUN))
if __name__ == '__main__':
try:
main()
except (Exception, KeyboardInterrupt) as exc:
# Avoid displaying command outputs or configuration containing secrets.
print('ABBRUCH: ' + (str(exc) if type(exc).__name__ in ('MigrationError', 'RuntimeError')
else type(exc).__name__), file=sys.stderr)
print('Vorhandene Ressourcen bleiben erhalten. Nicht blind erneut starten.', file=sys.stderr)
sys.exit(1)
File diff suppressed because one or more lines are too long
+1
View File
@@ -0,0 +1 @@
2c69fc5001d7fe09e8251bf379cb4121594387c6617ec011c97345a8f8af7443 migrate_ejbca_issuing.py
+4
View File
@@ -0,0 +1,4 @@
__pycache__/
*.pyc
token
.env
+53
View File
@@ -0,0 +1,53 @@
# HOMELAB
Lokale Webseite für eine Synology DS1817+ mit DSM 7.3.2 als Zielplattform.
Hauptseite `/`, DSM-Unterseite `/dsm`. Keine externen Dienste, Schriftarten oder Bibliotheken.
## Umfang
- CPU und RAM, aktuelle Übertragungsraten und Verlauf der letzten 60 Messungen.
- Physische Netzwerkschnittstellen mit Verbindungsstatus. Das ist NAS-Traffic, kein Router-/Internet-Monitoring. Bond- und Bridge-Interfaces werden nicht zusätzlich summiert.
- SMART-Gesamtzustand, Temperatur und Warnung bei SMART-Fehlerbits. Unlesbare oder schlafende Laufwerke bleiben „Unbekannt“. Keine Tests oder Änderungen an Laufwerken.
- LVM-Poolkapazitäten (zugewiesen/frei), Volume-Kapazitäten (belegt/frei), Linux-RAID-Zustand und Synchronisierungsaktion. DSM-Poolnamen und SHR-Zuordnung sind noch nicht auf dem Gerät validiert. LVM- und RAID-Zeilen sind keine garantierte Eins-zu-eins-Zuordnung zu DSM-Speicherpools.
- DNS-Paketneustart mit Dialog, Authentifizierung und 60 Sekunden Sperre zwischen Versuchen.
## Lokale Vorschau
Python 3 wird benötigt, keine zusätzlichen Pakete:
```sh
python3 server.py --demo
```
Danach `http://127.0.0.1:8787` öffnen. Alle Werte sind ausdrücklich Beispieldaten; Neustart ist gesperrt.
## Auf dem NAS starten
Die Einrichtung auf dem NAS wurde noch nicht ausgeführt. Python 3 muss dort vorhanden sein. Den gesamten Ordner beispielsweise nach `/volume1/homelab` kopieren und den tatsächlichen Python-Pfad verwenden. Programmdateien und Schlüsseldatei dürfen bei Ausführung als root nur für Administratoren schreibbar sein.
Einmal einen zufälligen Schlüssel erzeugen und in einer nur für root lesbaren Datei speichern, zum Beispiel `/volume1/homelab/token`. Erzeugung mit Python: `python3 -c 'import secrets; print(secrets.token_urlsafe(32))'`. Datei nicht in Git speichern. Den Schlüssel später im Dashboard eingeben; er wird nicht im Browser gespeichert.
Startskript für einen DSM-Aufgabenplaner-Task „Beim Hochfahren“, Benutzer root (Pfade anpassen):
```sh
#!/bin/sh
export HOMELAB_TOKEN="$(cat /volume1/homelab/token)"
# Erst nach Prüfung, dass das Synology-Paket DNSServer installiert ist:
# export HOMELAB_ALLOW_DNS_RESTART=1
exec /usr/local/bin/python3 /volume1/homelab/server.py --host 127.0.0.1 --port 8787
```
Der Dienst bindet standardmäßig nur an Loopback. In DSM einen HTTPS-Reverse-Proxy auf `http://127.0.0.1:8787` einrichten und über den lokalen Hostnamen öffnen. Den gesamten Pfad `/` weiterleiten. Kein öffentliches Portforwarding erforderlich. Für einen direkten LAN-Test kann `--host NAS-LAN-IP` verwendet werden; den Zugriffsschlüssel nur über HTTPS oder einen verschlüsselten Tunnel übertragen.
Das Backend benötigt erhöhte Leserechte für SMART/LVM; der optionale Paketneustart benötigt Verwaltungsrechte. Es führt ausschließlich den festen Befehl `/usr/syno/bin/synopkg restart DNSServer` aus. Keine frei übergebenen Shell-Befehle und keine DSM-Kennwörter im Frontend. Vor Aktivierung auf dem NAS die Existenz dieses Programms und des Pakets prüfen. Neustartbefehl und PID-Pfad sind auf DSM 7.3.2 noch nicht verifiziert. Ein erfolgreicher Befehl ist kein Nachweis einer erfolgreichen DNS-Anfrage.
## Grenzen und Prüfung auf dem NAS
- Noch keine Verbindung zu einer echten DS1817+; die Kompatibilität muss dort geprüft werden.
- SMART wird höchstens alle 60 Sekunden gelesen (`smartctl -n standby -a`). Fehlende Programme oder Berechtigungen ergeben unbekannte Werte.
- Die erste CPU-/Netzwerkmessung benötigt eine zweite Abfrage. Keine dauerhafte Messwertspeicherung.
- DNS-Status über `/var/packages/DNSServer/target/var/named.pid`; falls dieser Pfad abweicht, „Unbekannt“. Keine geratenen Erfolgszustände.
- Falls LVM auf dem Gerät nicht verfügbar ist, bleiben Poolkapazitäten offen; Volume-Werte werden unabhängig davon angezeigt.
- Python-Standard-HTTP-Server für ein privates Netz hinter dem DSM-Reverse-Proxy; nicht direkt ins Internet stellen.
Tests: `python3 -m unittest discover -s tests -v`
+405
View File
@@ -0,0 +1,405 @@
# DNS-Neustart aus Home Assistant Container
Ziel: `Madzone@192.168.1.230`, SSH-Port 22. Neustart ausschließlich des Synology-Pakets `DNSServer`. Docker-Container: **`HomeAssistant`** (Groß-/Kleinschreibung beachten).
## Geräte und Orte
| Ort | Erkennbarer Prompt | Verwendung |
| --- | --- | --- |
| Docker-Host | `root@Docker:~#` | Container finden, öffnen und neu starten |
| HA-Container `HomeAssistant` | `/config #` | SSH-Schlüssel, bekannte Server und HA-Konfiguration |
| Synology DS1817+, DSM 7.3.2 | `Madzone@NEW-SYNO:~$` | Gateway, sudo-Regel und öffentlicher Schlüssel |
Die Prompt-Zeichen und die bei mehrzeiligen Eingaben angezeigten `>` nicht mitkopieren. Ein alleinstehendes `EOF` beendet den jeweiligen Dateiblock. `exit` verlässt die Container-Shell und führt zum Docker-Host zurück.
## Bereits bestätigter Stand
- Gateway-Skript auf DSM installiert, Syntax geprüft; `/usr/local/sbin` und Skript haben Rechte `755`, Eigentümer root.
- DSM bindet `/etc/sudoers.d` ein; `visudo` ist nicht vorhanden. Die separate Regel wurde eingerichtet.
- Server-Fingerprints auf DSM und im HA-Container stimmen überein.
- `check-dns` aus dem HA-Container war erfolgreich, ohne DNS neu zu starten.
- HA-Konfigurationsprüfung zeigte nur `Testing configuration at /config`, keine Fehlermeldung.
- Ein tatsächlicher DNS-Neustart über den HA-Button wurde im Gespräch noch nicht bestätigt.
Für die laufende Einrichtung bei **Schritt 6** fortfahren. Die vorigen Schritte dokumentieren die vollständige Einrichtung und müssen nicht wiederholt werden. Eine erfolgreiche HA-Konfigurationsprüfung allein bestätigt noch nicht, dass das Package geladen wurde.
## 1. Schlüssel im Home-Assistant-Container erstellen
Auf dem Docker-Host wurde zuerst der tatsächliche Containername ermittelt:
```sh
sudo docker ps --format 'table {{.Names}}\t{{.Image}}'
```
Relevante Ausgabe:
```text
NAMES IMAGE
HomeAssistant homeassistant/home-assistant:latest
```
Auf deinem Docker-Host (`root@Docker`) den vorhandenen Container öffnen:
```sh
docker exec -it HomeAssistant sh
```
Ab jetzt im Container:
```sh
command -v ssh
command -v ssh-keygen
command -v ssh-keyscan
mkdir -p /config/ssh
chmod 700 /config/ssh
```
Bestätigte Programmpfade: `/usr/bin/ssh`, `/usr/bin/ssh-keygen` und `/usr/bin/ssh-keyscan`.
Falls eines der Programme fehlt, hier stoppen; dann muss das Container-Image passend erweitert werden. Keine nur vorübergehende Installation im laufenden Container.
Einen neuen, ausschließlich dafür verwendeten Schlüssel erzeugen. Vorhandene Datei nicht überschreiben:
```sh
if [ -e /config/ssh/synology_dns_ed25519 ]; then
echo 'Schlüssel existiert bereits – wird beibehalten.'
else
ssh-keygen -t ed25519 -N '' -f /config/ssh/synology_dns_ed25519 -C ha-dns-only
fi
chmod 600 /config/ssh/synology_dns_ed25519
cat /config/ssh/synology_dns_ed25519.pub
```
Bei dir wurde **„Schlüssel existiert bereits – wird beibehalten.“** ausgegeben. Es wurde kein neuer Schlüssel erzeugt. Dein öffentlicher Schlüssel lautet:
```text
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDK2Cxy/jmphN3gOaLssWnnhh9hUtCnwblGrUxDwS5ZE ha-dns-only
```
Nur die ausgegebene öffentliche Zeile wird auf DSM benötigt. Der private Schlüssel bleibt in `/config/ssh`; dieser Ordner muss im persistenten HA-Konfigurationsvolume liegen.
## 2. Auf DSM Paket und Rechte vorbereiten
Separat als `Madzone` auf DSM anmelden:
```sh
ssh Madzone@192.168.1.230
id
ls -l /usr/syno/bin/synopkg
ls -ld /var/packages/DNSServer
```
`Madzone` muss Administratorrechte besitzen. Wenn Paket oder Programm nicht vorhanden sind, nicht fortfahren.
Das Gateway direkt auf DSM erstellen; eine lokale Datei auf deinem Computer liegt nicht automatisch im NAS-Home-Verzeichnis:
```sh
cat > "$HOME/ha-dns-gateway.sh" <<'EOF'
#!/bin/sh
# Install on DSM as root-owned /usr/local/sbin/ha-dns-gateway.sh.
# Only used as the forced command of the dedicated Home Assistant SSH key.
set -eu
case "${SSH_ORIGINAL_COMMAND:-}" in
check-dns)
test -x /usr/syno/bin/synopkg
test -d /var/packages/DNSServer
sudo -n -l /usr/syno/bin/synopkg restart DNSServer >/dev/null
printf '%s\n' 'DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.'
;;
restart-dns)
test -x /usr/syno/bin/synopkg
test -d /var/packages/DNSServer
exec sudo -n /usr/syno/bin/synopkg restart DNSServer
;;
*)
printf '%s\n' 'Nur check-dns oder restart-dns ist erlaubt.' >&2
exit 64
;;
esac
EOF
sudo mkdir -p /usr/local/sbin
sudo cp "$HOME/ha-dns-gateway.sh" /usr/local/sbin/ha-dns-gateway.sh
sudo chown root:root /usr/local/sbin/ha-dns-gateway.sh
sudo chmod 755 /usr/local/sbin/ha-dns-gateway.sh
sudo sh -n /usr/local/sbin/ha-dns-gateway.sh
sudo ls -ld /usr /usr/local /usr/local/sbin
```
Auf deinem NAS wurde `/usr/local/sbin` mit `700` angelegt. Deshalb konnte Madzone das Skript trotz dessen `755`-Rechten nicht erreichen. Für dieses neu angelegte Verzeichnis wurde korrigiert:
```sh
sudo chmod 755 /usr/local/sbin
ls -l /usr/local/sbin/ha-dns-gateway.sh
```
Nicht rekursiv Rechte ändern. Das Verzeichnis und Skript bleiben nur für root schreibbar.
### Separate sudo-Regel ohne visudo
Auf deiner DSM ist `visudo` nicht vorhanden. Die Einbindung wurde geprüft:
```sh
sudo grep -nE '^[[:space:]]*([#@]include)' /etc/sudoers
sudo ls -ld /etc/sudoers.d
```
Bestätigte Ausgabe: `19:#includedir /etc/sudoers.d`. Das `#includedir` ist eine aktive sudo-Direktive, kein gewöhnlicher Kommentar.
Folgender Block legt nur die zusätzliche Regel an und überschreibt keine vorhandene Datei. `/etc/sudoers` bleibt unverändert:
```sh
sudo sh -c '
set -eu
target=/etc/sudoers.d/ha-dns
if [ -e "$target" ]; then
echo "Datei existiert bereits – nichts geändert."
exit 1
fi
umask 077
printf "%s\n" \
"Madzone ALL=(root) NOPASSWD: /usr/syno/bin/synopkg restart DNSServer" \
> "$target"
chown root:root "$target"
chmod 440 "$target"
'
```
Bei bereits vorhandener Datei den Inhalt mit `sudo cat /etc/sudoers.d/ha-dns` prüfen, nicht erneut anhängen. Anschließend als Madzone testen:
```sh
SSH_ORIGINAL_COMMAND=check-dns /usr/local/sbin/ha-dns-gateway.sh
```
Erwartet: `DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.` Dieser Check prüft die sudo-Regel, führt aber den privilegierten Neustart nicht aus. Er ersetzt keine vollständige Prüfung aller sudo-Regeln durch `visudo`.
## 3. Öffentlichen Schlüssel auf einen festen Befehl beschränken
Weiterhin in der DSM-Sitzung von Madzone:
```sh
mkdir -p "$HOME/.ssh"
chmod 700 "$HOME/.ssh"
touch "$HOME/.ssh/authorized_keys"
chmod 600 "$HOME/.ssh/authorized_keys"
```
Für deinen vorhandenen Schlüssel wurde folgender Eintrag vorbereitet. Auf DSM als Madzone ausführen, wenn dieser Schlüssel noch nicht eingetragen ist. Bei einem Treffer wird nichts angehängt; den vorhandenen Eintrag auf dieselben Einschränkungen prüfen:
```sh
if grep -qF 'AAAAC3NzaC1lZDI1NTE5AAAAIDK2Cxy/jmphN3gOaLssWnnhh9hUtCnwblGrUxDwS5ZE' "$HOME/.ssh/authorized_keys"; then
echo "Schlüssel bereits vorhanden – Eintrag vor Änderungen prüfen."
else
printf '\n%s\n' 'command="/usr/local/sbin/ha-dns-gateway.sh",no-port-forwarding,no-agent-forwarding,no-X11-forwarding,no-pty,no-user-rc ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDK2Cxy/jmphN3gOaLssWnnhh9hUtCnwblGrUxDwS5ZE ha-dns-only' >> "$HOME/.ssh/authorized_keys"
echo "Eingeschränkter Schlüssel eingetragen."
fi
```
Bei einem neu erzeugten Schlüssel muss die öffentliche Zeile und der Suchwert entsprechend ersetzt werden. Die Ausgabe dieses Eintragsschritts wurde nicht im Chat gezeigt; der spätere SSH-Test war erfolgreich.
Der Schlüssel darf damit nur `check-dns` und `restart-dns` ausführen, keine interaktive Shell oder Weiterleitungen. Der separate sudo-Eintrag erlaubt Madzone nur den angegebenen Paketneustart ohne Passwort; seine sonstigen bestehenden Administratorrechte bleiben bestehen. Bei Problemen mit dem Home-Verzeichnis den DSM-Benutzer-Home-Dienst und Dateieigentümer prüfen, nicht die SSH-Rechte lockern.
## 4. NAS-Identität prüfen und Verbindung ohne Neustart testen
In der bereits vertrauenswürdigen DSM-Sitzung den Fingerprint ablesen:
```sh
sudo ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
```
Im HA-Container:
```sh
ssh-keyscan -t ed25519 -p 22 192.168.1.230 > /config/ssh/synology_dns_known_hosts.pending
ssh-keygen -lf /config/ssh/synology_dns_known_hosts.pending
```
Bei deiner Einrichtung stimmten beide Fingerprints überein:
```text
SHA256:tIb+4+U9Ojztyqrj6fh2hqEIbNvshkR4hc7NRnO/zdI
```
Bei einer erneuten Einrichtung die aktuell ausgegebenen Fingerprints wieder miteinander vergleichen; nach einer Neuinstallation kann sich der Server-Schlüssel ändern. Beide SHA256-Fingerprints müssen übereinstimmen. Erst danach die geprüfte Datei übernehmen:
```sh
mv /config/ssh/synology_dns_known_hosts.pending /config/ssh/synology_dns_known_hosts
chmod 600 /config/ssh/synology_dns_known_hosts
ssh -F /dev/null -T -p 22 -i /config/ssh/synology_dns_ed25519 -o BatchMode=yes -o IdentitiesOnly=yes -o StrictHostKeyChecking=yes -o UserKnownHostsFile=/config/ssh/synology_dns_known_hosts -o ConnectTimeout=10 Madzone@192.168.1.230 check-dns
```
Erwartet: `DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.` Dieser Test prüft SSH, Programmpfad, Paketverzeichnis und sudo-Freigabe. Er startet DNS nicht neu und bestätigt noch nicht, dass ein späterer Neustart erfolgreich sein wird.
Beim erfolgreichen Test erschien zusätzlich die Warnung `connection is not using a post-quantum key exchange algorithm`. Sie verhinderte die Anmeldung und den Test nicht. Die Host-Key-Prüfung bleibt aktiviert; die Warnung wird nicht durch Abschalten von SSH-Schutzoptionen umgangen.
## 5. HA-Konfiguration installieren
Im HA-Container bei Bedarf `mkdir -p /config/packages` ausführen. Die mitgelieferte Datei [synology-dns.yaml](synology-dns.yaml) als `/config/packages/synology_dns.yaml` in das HA-Konfigurationsvolume kopieren. Der Quelldateiname enthält einen Bindestrich, der hier gewählte Zieldateiname einen Unterstrich. Nur eine Kopie des Packages installieren.
Damit die Anleitung auch ohne separates Kopieren der Datei vollständig ist, hier der komplette Inhalt für `/config/packages/synology_dns.yaml`. Einen eventuell vorhandenen Stand vorher sichern und nicht zusätzlich eine zweite Package-Datei mit denselben Schlüsseln anlegen:
```yaml
# Nach /config/packages/synology_dns.yaml kopieren.
shell_command:
synology_dns_restart: >-
ssh -F /dev/null -T -p 22
-i /config/ssh/synology_dns_ed25519
-o BatchMode=yes -o IdentitiesOnly=yes
-o StrictHostKeyChecking=yes
-o UserKnownHostsFile=/config/ssh/synology_dns_known_hosts
-o ConnectTimeout=10 -o ServerAliveInterval=5 -o ServerAliveCountMax=2
Madzone@192.168.1.230 restart-dns
script:
synology_dns_restart:
alias: Synology · DNS Server neu starten
icon: mdi:dns
mode: single
sequence:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS Server
message: Neustartbefehl wird gesendet …
- variables:
dns_result:
returncode: -1
- action: shell_command.synology_dns_restart
response_variable: dns_result
continue_on_error: true
- choose:
- conditions: "{{ dns_result is defined and dns_result is mapping and dns_result.get('returncode', -1) == 0 }}"
sequence:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS Server
message: >-
Der DNS-Neustartbefehl wurde erfolgreich ausgeführt.
Das NAS wurde nicht neu gestartet. Die DNS-Auflösung wurde nicht separat geprüft.
default:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS · Neustart nicht bestätigt
message: >-
SSH oder der Neustartbefehl ist fehlgeschlagen, oder das Zeitlimit wurde erreicht.
Prüfe den DNS-Paketstatus in DSM und das Home-Assistant-Protokoll,
bevor du einen weiteren Neustart auslöst.
- delay: '00:01:00'
```
In `/config/configuration.yaml` Packages einbinden. Falls bereits ein `homeassistant:`-Abschnitt existiert, dort ergänzen; keinen zweiten gleichnamigen Abschnitt anlegen. Vorhandene Packages-Konfiguration nicht ersetzen:
```yaml
homeassistant:
packages: !include_dir_named packages
```
Konfiguration auf dem Docker-Host prüfen:
```sh
docker exec HomeAssistant python -m homeassistant --script check_config --config /config
```
Alternativ direkt in der bereits geöffneten Container-Sitzung:
```sh
python -m homeassistant --script check_config --config /config
```
Deine tatsächliche Ausgabe:
```text
/config # python -m homeassistant --script check_config --config /config
Testing configuration at /config
/config #
```
Die Ausgabe enthielt keine Fehlermeldung. Bei Fehlern erst die Konfiguration korrigieren.
## 6. Home Assistant neu starten
Wenn du noch am Prompt `/config #` bist, mit `exit` zum Docker-Host zurückkehren. Dort:
```sh
docker restart HomeAssistant
```
Das startet nur Home Assistant neu, nicht die Synology oder deren DNS-Paket. Warten, bis HA wieder erreichbar ist. Unter Entwicklerwerkzeuge → Zustände nach `script.synology_dns_restart` suchen. Fehlt es, Package-Pfad, Include-Einbindung und HA-Protokoll prüfen.
## 7. Dashboard aktualisieren und DNS neu starten
Den aktualisierten Inhalt von `dashboard.yaml` im Rohkonfigurationseditor deines HOMELAB-Dashboards übernehmen. Auf DSM → **DNS Server neu starten** klicken und die Sicherheitsabfrage bestätigen. Jetzt wird erstmals der tatsächliche DNS-Neustart ausgeführt.
Falls du nur die vorhandene DNS-Karte bearbeiten möchtest, lautet deren YAML:
```yaml
type: button
entity: script.synology_dns_restart
name: DNS Server neu starten
icon: mdi:dns
show_state: true
tap_action:
action: perform-action
perform_action: script.synology_dns_restart
confirmation:
text: DNS Server auf 192.168.1.230 neu starten? Die Namensauflösung kann kurz ausfallen.
hold_action:
action: none
double_tap_action:
action: none
```
Dieser Block ist eine einzelne Karte; die vollständige `dashboard.yaml` gehört dagegen in den Dashboard-Rohkonfigurationseditor. Die bestehende HOMELAB-Startseite mit separater DSM-Unterseite und Graphen bleibt erhalten.
Der Button ruft das HA-Skript auf. Es zeigt das Ergebnis als persistente HA-Benachrichtigung an und sperrt weitere Skriptaufrufe während der Ausführung plus 60 Sekunden danach. Ein Erfolg bedeutet, dass der Paketbefehl Exitcode 0 zurückgegeben hat; eine DNS-Abfrage wurde damit nicht geprüft.
Bei Fehler oder Zeitüberschreitung zuerst Paketstatus in DSM und HA-Protokoll prüfen. HA beendet Shell-Befehle nach 60 Sekunden; der entfernte Vorgang könnte trotzdem weiterlaufen. Nicht sofort wiederholt starten.
Nach DSM-Updates gegebenenfalls sudo-Regel, Gateway-Datei und SSH-Zugang prüfen. Zum Entfernen: HA-Package und Button entfernen, genau den `ha-dns-only`-Schlüsseleintrag aus `authorized_keys` löschen, die ausschließlich hierfür angelegte Datei `/etc/sudoers.d/ha-dns` entfernen (zuvor Inhalt prüfen) und die nur hierfür angelegten Schlüssel-/Gateway-Dateien entfernen.
## Ablaufprotokoll der tatsächlich gezeigten Einrichtung
Die folgende Reihenfolge entspricht den Terminalausgaben im Gespräch. Die obige Anleitung ist für eine erneute Einrichtung nach Aufgaben geordnet.
| Schritt | Beobachtung / Ergebnis | Lösung oder Folgeschritt |
| --- | --- | --- |
| Gateway kopieren | `cp: cannot stat '/var/services/homes/Madzone/ha-dns-gateway.sh': No such file or directory` | Skript direkt mit `cat … <<'EOF'` in Madzones Home erstellt. |
| Gateway installieren | `mkdir`, `cp`, `chown root:root`, `chmod 755` liefen ohne Fehler. | Datei lag unter `/usr/local/sbin/ha-dns-gateway.sh`. |
| Datei als Madzone ansehen | `Permission denied` trotz ausführbarer Datei. | Verzeichnisse mit `sudo ls -ld /usr /usr/local /usr/local/sbin` geprüft. |
| Rechte und Syntax prüfen | `/usr/local/sbin` hatte `drwx------`; Datei `-rwxr-xr-x root root`; `sudo sh -n` blieb ohne Ausgabe. | `sudo chmod 755 /usr/local/sbin`; danach konnte Madzone die Datei auflisten. |
| sudo-Regel bearbeiten | `sudo: visudo: command not found` | Bekannte Programmpfade geprüft; kein `visudo` gefunden. |
| Include-Verzeichnis prüfen | `19:#includedir /etc/sudoers.d`, Verzeichnis vorhanden. | Separate Datei `/etc/sudoers.d/ha-dns` mit der festen Regel vorgesehen. |
| Lokaler Gateway-Test | `DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.` | Programmpfad, Paketverzeichnis und sudo-Regel erfolgreich geprüft. |
| Container ermitteln | `HomeAssistant`, Image `homeassistant/home-assistant:latest`. | `docker exec -it HomeAssistant sh`. |
| SSH-Werkzeuge prüfen | Alle drei Programme unter `/usr/bin/` vorhanden. | `/config/ssh` mit `700` angelegt. |
| Client-Schlüssel | Schlüssel bereits vorhanden; beibehalten, privater Schlüssel auf `600` gesetzt. | Öffentlichen Schlüssel aus `.pub` abgelesen. |
| Schlüssel auf DSM | Eingeschränkter `authorized_keys`-Eintrag bereitgestellt; keine separate Eintragsausgabe gezeigt. | Erfolgreicher nachfolgender SSH-Test bestätigt den Zugang. |
| Server-Identität | Beide Fingerprints identisch: `SHA256:tIb+4+U9Ojztyqrj6fh2hqEIbNvshkR4hc7NRnO/zdI`. | Geprüfte `.pending`-Datei nach `synology_dns_known_hosts` verschoben, Rechte `600`. |
| SSH-Test aus HA | Post-Quantum-Warnung, danach erfolgreiche `check-dns`-Meldung. | Kein DNS-Neustart durchgeführt. |
| HA-Package | Package und Include-Anleitung bereitgestellt; Dateiinhalt auf HA nicht separat ausgegeben. | Anschließend HA-Konfiguration geprüft. |
| HA-Konfigurationsprüfung | Nur `Testing configuration at /config`, keine Fehler. | HA-Neustart empfohlen. |
| HA-Neustart und DNS-Button | Befehle/Bedienung beschrieben, noch keine Erfolgsausgabe vom Benutzer vorgelegt. | Noch nicht als ausgeführt oder erfolgreich dokumentiert. |
### Befehle zur damaligen Fehlerdiagnose
Diese Prüfungen sind hier der Vollständigkeit halber aufgeführt; die Fehler sind bereits behoben:
```sh
sudo ls -ld /usr /usr/local /usr/local/sbin
sudo ls -l /usr/local/sbin/ha-dns-gateway.sh
sudo sh -n /usr/local/sbin/ha-dns-gateway.sh
sudo sh -c '
for p in /usr/sbin/visudo /usr/bin/visudo /sbin/visudo /bin/visudo /usr/local/sbin/visudo; do
[ ! -x "$p" ] || printf "%s\n" "$p"
done
grep -nE "^[[:space:]]*([#@]include)" /etc/sudoers
ls -ld /etc/sudoers.d
'
```
Offizielle HA-Dokumentation:
- https://www.home-assistant.io/integrations/shell_command/
- https://www.home-assistant.io/docs/configuration/packages/
- https://www.home-assistant.io/dashboards/actions/
+81
View File
@@ -0,0 +1,81 @@
# HOMELAB in Home Assistant
Diese Konfiguration ersetzt für diesen Anwendungsfall die separate Python-Webseite im übergeordneten Ordner. Python-Dienst und Demo werden nicht benötigt.
## Einfügen
1. Einstellungen → Dashboards → Dashboard hinzufügen. Ein neues, leeres, selbst verwaltetes Dashboard erstellen.
2. Titel **HOMELAB**, Icon `mdi:home-network`, URL **dashboard-homelab** festlegen. In der Seitenleiste anzeigen.
3. Neues Dashboard öffnen → Bearbeiten → Drei-Punkte-Menü → Rohkonfigurationseditor.
4. Den gesamten Inhalt von `dashboard.yaml` einfügen und speichern. Nur die Konfiguration des neuen Dashboards ersetzen.
5. Auf der HOMELAB-Startseite die große DSM-Kachel öffnen. Die DSM-Unterseite enthält alle Detailanzeigen und einen Zurück-Pfeil zur Startseite.
Die Datei ist eine vollständige Dashboard-Konfiguration, keine einzelne Karte und kein Eintrag für `configuration.yaml`.
Es werden ausschließlich integrierte Karten verwendet; HACS, Mushroom und zusätzliche Frontend-Ressourcen sind nicht notwendig. Das Layout passt sich der Bildschirmbreite an. Die Graphen benötigen Messwertverlauf im Home-Assistant-Recorder.
## Bereits verbunden
Die 64 Messwert- und Status-Entitäten stammen aus der gelieferten Liste; zusätzlich verwendet der DNS-Button das separat eingerichtete `script.synology_dns_restart`: CPU, RAM, NAS-Temperatur, Sicherheitsstatus, Netzwerkdurchsatz, Volume 1, acht interne Laufwerke und zwei USB-Laufwerke. Die Anzeige übernimmt Einheiten direkt aus Home Assistant.
RAM-Auslastung kommt direkt aus dem Prozent-Sensor. Sie wird nicht aus Gesamt-RAM minus verfügbarem RAM berechnet, da die gelieferten Werte unterschiedliche Speicherkategorien abbilden können.
## Noch offen
- **Netzwerk-Linkstatus:** Es wurde kein eigener Link-/Erreichbarkeitssensor geliefert. Empfangene CPU-Daten zeigen die Messwertverfügbarkeit; daraus wird kein angeblich aktueller Ethernet-Linkstatus abgeleitet.
- **SMART und Volume-Kapazität ergänzt:** Die neue Liste enthält SMART-Status für alle acht Laufwerke, Volume-Gesamtgröße und maximale Laufwerkstemperatur. Diese sind jetzt eingebaut; außerdem ein SMART-Verlauf über 24 Stunden. Freier Volume-Speicher wird als Gesamtgröße minus belegtem Speicher berechnet und bei fehlenden oder widersprüchlichen Werten nicht angezeigt.
- **Speicherpool:** Echte Pool-Sensoren fehlen weiterhin. Volume-Größe und -Zustand werden ausdrücklich als Volume-Werte angezeigt, nicht als Pool-Werte.
- **DNS-Neustart:** Button und HA-Package sind für `Madzone@192.168.1.230:22` vorbereitet. Die einmalige SSH-Einrichtung und Installation stehen in [DNS-SETUP.md](DNS-SETUP.md). Gateway und sudo-Regel sind auf DSM eingerichtet; der SSH-Prüfbefehl aus dem Container **HomeAssistant** war erfolgreich. Die HA-Konfigurationsprüfung zeigte keine Fehler. Der tatsächliche DNS-Neustart per Button ist noch nicht bestätigt.
Die Aktualisierungsrate wird von der Integration bestimmt, nicht vom Dashboard. Die offizielle Dokumentation nennt standardmäßig 15 Minuten und beschreibt eine individuelle Polling-Konfiguration. Es wird hier keine aggressive Abfrageautomatik hinzugefügt.
## Prüfung
YAML wurde geparst; Messwert- und Status-Entitäten wurden mit der gelieferten Liste abgeglichen. Die vom Benutzer gelieferten HA-Screenshots zeigen Messwerte und Graphen auf beiden Seiten. DNS-Verbindung und Berechtigungsprüfung sind durch die Terminalausgaben bestätigt; der Neustart über den Button bleibt noch zu prüfen.
Referenzen:
- https://www.home-assistant.io/integrations/synology_dsm/
- https://www.home-assistant.io/dashboards/views/
- https://www.home-assistant.io/dashboards/actions/
## Grafische Ansicht
Die ursprüngliche Anordnung ist wiederhergestellt: HOMELAB-Startseite mit DSM-Kachel, vier Verlaufskacheln und Volume-Anzeige; separate DSM-Unterseite mit allen bisherigen Karten und der ergänzten SMART-Verlaufskarte einschließlich Graphen und DNS-Button. Weitere Systeme können später ergänzt werden.
Bei einem anderen Dashboard-URL-Pfad `navigation_path` und `back_path` entsprechend anpassen.
Die Graphen zeigen nur tatsächlich gespeicherte Messwerte. Neue oder vom Recorder ausgeschlossene Sensoren haben noch keinen Verlauf.
YAML, Kartenanzahl und DNS-Aktion wurden geprüft. Keine direkte Änderung in der laufenden Home-Assistant-Instanz.
## Letzte übermittelte Werte
Alle acht SMART-Sensoren meldeten `normal`. Volume 1: 26,810903851008 TB gesamt, 12,022071693312 TB belegt, daraus 14,788832157696 TB frei. Laufwerkstemperaturen 32–35 °C. Diese Werte sind eine Momentaufnahme aus der übermittelten Liste; das Dashboard liest die Entitäten dynamisch. Neu aktivierte SMART-Sensoren benötigen erst Verlaufshistorie.
## Geordnete DSM-Ansicht
Die DSM-Unterseite verwendet jetzt das native Sections-Layout mit maximal drei Spalten:
| Erste Reihe | | |
| --- | --- | --- |
| System | Netzwerk & DNS | Speicher · Volume 1 |
| Laufwerke 1–4 | Laufwerke 5–8 | SMART & USB-Speicher |
Die automatische Lückenfüllung ist deaktiviert, damit die Reihenfolge der Bereiche erhalten bleibt. Auf schmaleren Bildschirmen reduziert Home Assistant die Spaltenzahl. Alle bisherigen Messwerte, Graphen und DNS-Aktionen bleiben erhalten; die HOMELAB-Startseite ist unverändert.
Die bisherige Konfiguration ist als `dashboard-vor-sortierung.yaml` gesichert. Die neue Anordnung ist noch nicht in deiner laufenden HA-Oberfläche visuell geprüft.
## OPNsense · ALG
Die HOMELAB-Startseite enthält zusätzlich eine OPNsense-Kachel. Die neue Unterseite `/dashboard-homelab/opnsense` verwendet dieselbe Struktur mit maximal drei Spalten wie DSM. Die vorhandene DSM-Unterseite wurde unverändert übernommen.
- Erste Reihe: System (CPU, RAM, Temperaturzonen, Last und Dateisystem), WAN mit Durchsatz und Gateway-Verlauf, Status und Hinweise.
- Weitere Bereiche: LAN, DMZ, PROXY, TRANSFER jeweils mit Status und Eingangs-/Ausgangsgraphen; Loopback separat.
- Alle 32 Entitäten sind mit der gelieferten OPNsense-Liste abgeglichen. Es sind keine zusätzlichen HA-Templates, HACS-Karten oder Konfigurations-Packages erforderlich.
- LAN meldete in der gelieferten Momentaufnahme `no carrier`. Ein bedingter Hinweis erscheint nur bei diesem Zustand. Dies ist kein Beweis, dass die gesamte Firewall offline ist.
- WAN in/out wird aus Sicht der Firewall beschriftet. Interne Schnittstellen werden nicht als Internet-Download/-Upload bezeichnet oder zu einem Gesamtdurchsatz addiert.
- Temperaturzonen bleiben Zone 0 und Zone 1, da ihre genaue Hardware-Zuordnung nicht geliefert wurde.
- Die DHCP-Abfrage meldete 0 Leases; daraus wird keine Anzahl verbundener Geräte abgeleitet.
- Firmware-Update wird als Textstatus dargestellt, ohne Update-Aktion. Firewall-/Regeländerungen oder Neustartaktionen sind nicht Bestandteil dieser Ansicht.
Zum Übernehmen den vollständigen Inhalt von `dashboard.yaml` im Rohkonfigurationseditor des bestehenden HOMELAB-Dashboards ersetzen. Falls du inzwischen eigene Änderungen vorgenommen hast, vorher deine aktuelle Konfiguration sichern. Die neue OPNsense-Seite wurde auf YAML und Entitäten geprüft, aber noch nicht in deiner HA-Oberfläche gerendert.
@@ -0,0 +1,432 @@
# HOMELAB: Dashboard-URL dashboard-homelab
---
title: HOMELAB
views:
- title: HOMELAB
path: home
icon: mdi:home-network
cards:
- type: markdown
content: |
# HOMELAB
Deine Infrastruktur auf einen Blick.
- type: button
name: DSM · Synology DS1817+
icon: mdi:nas
show_state: false
tap_action:
action: navigate
navigation_path: "/dashboard-homelab/dsm"
hold_action:
action: none
- type: grid
columns: 2
square: false
cards:
- type: sensor
entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
limits:
min: 0
max: 100
- type: sensor
entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
limits:
min: 0
max: 100
- type: sensor
entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download · 6 Stunden
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload · 6 Stunden
graph: line
detail: 2
hours_to_show: 6
- type: gauge
entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1 · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
- title: DSM
path: dsm
subview: true
back_path: "/dashboard-homelab/home"
icon: mdi:nas
cards:
- type: markdown
content: |
# DSM · DS1817+
**Zielsystem: DSM 7.3.2** · Werte aus deiner Synology-Integration.
{% set cpu = states.sensor.datennutzung_new_syno_cpu_auslastung_gesamt %}
{% if cpu.state in ['unknown', 'unavailable'] %}
⚠️ **Messwerte nicht verfügbar.** Integration und NAS-Verbindung prüfen.
{% else %}
**CPU-Messwert empfangen:** {{ as_local(cpu.last_reported).strftime('%d.%m.%Y %H:%M:%S') }}
{% endif %}
Netzwerkraten gelten für das NAS. Die Aktualisierung erfolgt durch die Integration.
- type: horizontal-stack
cards:
- type: gauge
entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 70
red: 90
- type: gauge
entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
- type: history-graph
title: CPU & RAM · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU
- entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM
- type: sensor
entity: sensor.datennutzung_new_syno_temperatur
name: Systemtemperatur · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
- type: entities
title: System
show_header_toggle: false
entities:
- entity: sensor.datennutzung_new_syno_temperatur
name: Systemtemperatur
- entity: sensor.datennutzung_new_syno_speicher_gesamt_real
name: RAM gesamt
- entity: sensor.datennutzung_new_syno_speicher_verfugbar_real
name: RAM verfügbar · DSM-Messwert
- entity: sensor.datennutzung_new_syno_durchschnittliche_cpu_last_5_min
name: CPU-Last · 5 Minuten
- entity: sensor.datennutzung_new_syno_durchschnittliche_cpu_last_15_min
name: CPU-Last · 15 Minuten
- entity: binary_sensor.datennutzung_new_syno_sicherheitsstatus
name: Sicherheitswarnung
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload
graph: line
detail: 2
hours_to_show: 6
- type: history-graph
title: Netzwerk · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download
- entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload
- type: gauge
entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1 · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
- type: sensor
entity: sensor.new_syno_volume_1_belegter_speicherplatz
name: Volume 1 · Belegter Speicher · 7 Tage
graph: line
detail: 2
hours_to_show: 168
- type: entities
title: Volume 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_volume_1_status
name: Zustand
- entity: sensor.new_syno_volume_1_belegter_speicherplatz
name: Belegter Speicher
- entity: sensor.new_syno_volume_1_volume_nutzung
name: Belegung
- entity: sensor.new_syno_volume_1_durchschnittliche_festplattentemperatur
name: Mittlere Laufwerkstemperatur
- entity: sensor.new_syno_volume_1_gesamtgrosse
name: Gesamtkapazität
- entity: sensor.new_syno_volume_1_maximale_festplattentemperatur
name: Höchste Laufwerkstemperatur
- type: markdown
title: Volume 1 · Kapazität
content: |
{% set total = states('sensor.new_syno_volume_1_gesamtgrosse') %}
{% set used = states('sensor.new_syno_volume_1_belegter_speicherplatz') %}
{% if is_number(total) and is_number(used) and total | float >= used | float and used | float >= 0 %}
| Gesamt | Belegt | Frei (berechnet) |
| :--- | :--- | :--- |
| {{ total | float | round(2) }} TB | {{ used | float | round(2) }} TB | {{ ((total | float) - (used | float)) | round(2) }} TB |
{% else %}
**Kapazitätsdaten fehlen oder sind widersprüchlich.** Freier Speicher kann nicht berechnet werden.
{% endif %}
Angaben für **Volume 1**. Echte Speicherpool-Kapazitäten und Pool-Zustand werden von den vorhandenen Entitäten nicht bereitgestellt.
- type: history-graph
title: SMART-Status · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_1_status_smart
name: Laufwerk 1
- entity: sensor.new_syno_drive_2_status_smart
name: Laufwerk 2
- entity: sensor.new_syno_drive_3_status_smart
name: Laufwerk 3
- entity: sensor.new_syno_drive_4_status_smart
name: Laufwerk 4
- entity: sensor.new_syno_drive_5_status_smart
name: Laufwerk 5
- entity: sensor.new_syno_drive_6_status_smart
name: Laufwerk 6
- entity: sensor.new_syno_drive_7_status_smart
name: Laufwerk 7
- entity: sensor.new_syno_drive_8_status_smart
name: Laufwerk 8
- type: vertical-stack
cards:
- type: markdown
content: "## Laufwerke · Einschübe 1–4"
- type: history-graph
title: Laufwerkstemperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_1_temperatur
name: Laufwerk 1
- entity: sensor.new_syno_drive_2_temperatur
name: Laufwerk 2
- entity: sensor.new_syno_drive_3_temperatur
name: Laufwerk 3
- entity: sensor.new_syno_drive_4_temperatur
name: Laufwerk 4
- type: entities
title: Laufwerk 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_1_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_1_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_1_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_1_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_1_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 2
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_2_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_2_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_2_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_2_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_2_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 3
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_3_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_3_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_3_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_3_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_3_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 4
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_4_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_4_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_4_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_4_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_4_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: vertical-stack
cards:
- type: markdown
content: "## Laufwerke · Einschübe 5–8"
- type: history-graph
title: Laufwerkstemperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_5_temperatur
name: Laufwerk 5
- entity: sensor.new_syno_drive_6_temperatur
name: Laufwerk 6
- entity: sensor.new_syno_drive_7_temperatur
name: Laufwerk 7
- entity: sensor.new_syno_drive_8_temperatur
name: Laufwerk 8
- type: entities
title: Laufwerk 5
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_5_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_5_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_5_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_5_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_5_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 6
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_6_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_6_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_6_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_6_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_6_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 7
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_7_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_7_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_7_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_7_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_7_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 8
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_8_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_8_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_8_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_8_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_8_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: history-graph
title: Speicherbelegung · 7 Tage
hours_to_show: 168
entities:
- entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzte_partition
name: USB 1
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzte_partition
name: USB 2
- type: entities
title: USB-Laufwerk 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_usb_disk_1_status
name: Zustand
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzte_partition
name: Belegung
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzter_partitionsplatz
name: Belegter Speicher
- entity: sensor.new_syno_usb_disk_1_partition_1_partitionsgrosse
name: Gesamtkapazität
- type: entities
title: USB-Laufwerk 2
show_header_toggle: false
entities:
- entity: sensor.new_syno_usb_disk_2_status
name: Zustand
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzte_partition
name: Belegung
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzter_partitionsplatz
name: Belegter Speicher
- entity: sensor.new_syno_usb_disk_2_partition_1_partitionsgrosse
name: Gesamtkapazität
- type: vertical-stack
cards:
- type: markdown
content: |
## DNS Server
Neustart des DNS-Pakets auf **192.168.1.230**.
SSH-Einrichtung gemäß DNS-SETUP.md erforderlich. Das Ergebnis erscheint als HA-Benachrichtigung.
- type: button
entity: script.synology_dns_restart
name: DNS Server neu starten
icon: mdi:dns
show_state: true
tap_action:
action: perform-action
perform_action: script.synology_dns_restart
confirmation:
text: DNS Server auf 192.168.1.230 neu starten? Die Namensauflösung kann
kurz ausfallen.
hold_action:
action: none
double_tap_action:
action: none
+965
View File
@@ -0,0 +1,965 @@
# HOMELAB: Dashboard-URL dashboard-homelab
# Unterseiten: DSM und OPNsense
---
title: HOMELAB
views:
- title: HOMELAB
path: home
icon: mdi:home-network
cards:
- type: markdown
content: |
# HOMELAB
Deine Infrastruktur auf einen Blick.
- type: button
name: DSM · Synology DS1817+
icon: mdi:nas
show_state: false
tap_action:
action: navigate
navigation_path: "/dashboard-homelab/dsm"
hold_action:
action: none
- type: button
name: OPNsense · ALG
icon: mdi:shield-lock
show_state: false
tap_action:
action: navigate
navigation_path: "/dashboard-homelab/opnsense"
hold_action:
action: none
- type: grid
columns: 2
square: false
cards:
- type: sensor
entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
limits:
min: 0
max: 100
- type: sensor
entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
limits:
min: 0
max: 100
- type: sensor
entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download · 6 Stunden
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload · 6 Stunden
graph: line
detail: 2
hours_to_show: 6
- type: gauge
entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1 · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
- title: DSM
path: dsm
subview: true
back_path: "/dashboard-homelab/home"
icon: mdi:nas
type: sections
max_columns: 3
dense_section_placement: false
header:
card:
type: markdown
content: |
# DSM · DS1817+
**Zielsystem: DSM 7.3.2** · Werte aus deiner Synology-Integration.
{% set cpu = states.sensor.datennutzung_new_syno_cpu_auslastung_gesamt %}
{% if cpu.state in ['unknown', 'unavailable'] %}
⚠️ **Messwerte nicht verfügbar.** Integration und NAS-Verbindung prüfen.
{% else %}
**CPU-Messwert empfangen:** {{ as_local(cpu.last_reported).strftime('%d.%m.%Y %H:%M:%S') }}
{% endif %}
Netzwerkraten gelten für das NAS. Die Aktualisierung erfolgt durch die Integration.
layout: start
sections:
- type: grid
cards:
- type: heading
heading: System
heading_style: title
icon: mdi:chip
- type: horizontal-stack
cards:
- type: gauge
entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 70
red: 90
- type: gauge
entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
grid_options:
columns: 12
rows: auto
- type: history-graph
title: CPU & RAM · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU
- entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM
grid_options:
columns: 12
rows: auto
- type: sensor
entity: sensor.datennutzung_new_syno_temperatur
name: Systemtemperatur · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
grid_options:
columns: 12
rows: auto
- type: entities
title: System
show_header_toggle: false
entities:
- entity: sensor.datennutzung_new_syno_temperatur
name: Systemtemperatur
- entity: sensor.datennutzung_new_syno_speicher_gesamt_real
name: RAM gesamt
- entity: sensor.datennutzung_new_syno_speicher_verfugbar_real
name: RAM verfügbar · DSM-Messwert
- entity: sensor.datennutzung_new_syno_durchschnittliche_cpu_last_5_min
name: CPU-Last · 5 Minuten
- entity: sensor.datennutzung_new_syno_durchschnittliche_cpu_last_15_min
name: CPU-Last · 15 Minuten
- entity: binary_sensor.datennutzung_new_syno_sicherheitsstatus
name: Sicherheitswarnung
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Netzwerk & DNS
heading_style: title
icon: mdi:network
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: Netzwerk · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download
- entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload
grid_options:
columns: 12
rows: auto
- type: vertical-stack
cards:
- type: markdown
content: |
## DNS Server
Neustart des DNS-Pakets auf **192.168.1.230**.
SSH-Einrichtung gemäß DNS-SETUP.md erforderlich. Das Ergebnis erscheint als HA-Benachrichtigung.
- type: button
entity: script.synology_dns_restart
name: DNS Server neu starten
icon: mdi:dns
show_state: true
tap_action:
action: perform-action
perform_action: script.synology_dns_restart
confirmation:
text: DNS Server auf 192.168.1.230 neu starten? Die Namensauflösung kann
kurz ausfallen.
hold_action:
action: none
double_tap_action:
action: none
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Speicher · Volume 1
heading_style: title
icon: mdi:database
- type: gauge
entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1 · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
grid_options:
columns: 12
rows: auto
- type: markdown
title: Volume 1 · Kapazität
content: |
{% set total = states('sensor.new_syno_volume_1_gesamtgrosse') %}
{% set used = states('sensor.new_syno_volume_1_belegter_speicherplatz') %}
{% if is_number(total) and is_number(used) and total | float >= used | float and used | float >= 0 %}
| Gesamt | Belegt | Frei (berechnet) |
| :--- | :--- | :--- |
| {{ total | float | round(2) }} TB | {{ used | float | round(2) }} TB | {{ ((total | float) - (used | float)) | round(2) }} TB |
{% else %}
**Kapazitätsdaten fehlen oder sind widersprüchlich.** Freier Speicher kann nicht berechnet werden.
{% endif %}
Angaben für **Volume 1**. Echte Speicherpool-Kapazitäten und Pool-Zustand werden von den vorhandenen Entitäten nicht bereitgestellt.
grid_options:
columns: 12
rows: auto
- type: sensor
entity: sensor.new_syno_volume_1_belegter_speicherplatz
name: Volume 1 · Belegter Speicher · 7 Tage
graph: line
detail: 2
hours_to_show: 168
grid_options:
columns: 12
rows: auto
- type: entities
title: Volume 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_volume_1_status
name: Zustand
- entity: sensor.new_syno_volume_1_belegter_speicherplatz
name: Belegter Speicher
- entity: sensor.new_syno_volume_1_volume_nutzung
name: Belegung
- entity: sensor.new_syno_volume_1_durchschnittliche_festplattentemperatur
name: Mittlere Laufwerkstemperatur
- entity: sensor.new_syno_volume_1_gesamtgrosse
name: Gesamtkapazität
- entity: sensor.new_syno_volume_1_maximale_festplattentemperatur
name: Höchste Laufwerkstemperatur
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Laufwerke 1–4
heading_style: title
icon: mdi:harddisk
- type: history-graph
title: Laufwerkstemperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_1_temperatur
name: Laufwerk 1
- entity: sensor.new_syno_drive_2_temperatur
name: Laufwerk 2
- entity: sensor.new_syno_drive_3_temperatur
name: Laufwerk 3
- entity: sensor.new_syno_drive_4_temperatur
name: Laufwerk 4
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_1_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_1_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_1_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_1_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_1_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 2
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_2_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_2_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_2_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_2_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_2_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 3
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_3_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_3_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_3_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_3_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_3_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 4
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_4_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_4_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_4_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_4_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_4_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Laufwerke 5–8
heading_style: title
icon: mdi:harddisk
- type: history-graph
title: Laufwerkstemperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_5_temperatur
name: Laufwerk 5
- entity: sensor.new_syno_drive_6_temperatur
name: Laufwerk 6
- entity: sensor.new_syno_drive_7_temperatur
name: Laufwerk 7
- entity: sensor.new_syno_drive_8_temperatur
name: Laufwerk 8
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 5
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_5_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_5_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_5_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_5_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_5_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 6
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_6_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_6_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_6_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_6_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_6_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 7
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_7_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_7_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_7_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_7_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_7_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 8
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_8_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_8_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_8_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_8_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_8_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: SMART & USB-Speicher
heading_style: title
icon: mdi:harddisk-check
- type: history-graph
title: SMART-Status · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_1_status_smart
name: Laufwerk 1
- entity: sensor.new_syno_drive_2_status_smart
name: Laufwerk 2
- entity: sensor.new_syno_drive_3_status_smart
name: Laufwerk 3
- entity: sensor.new_syno_drive_4_status_smart
name: Laufwerk 4
- entity: sensor.new_syno_drive_5_status_smart
name: Laufwerk 5
- entity: sensor.new_syno_drive_6_status_smart
name: Laufwerk 6
- entity: sensor.new_syno_drive_7_status_smart
name: Laufwerk 7
- entity: sensor.new_syno_drive_8_status_smart
name: Laufwerk 8
grid_options:
columns: 12
rows: auto
- type: history-graph
title: Speicherbelegung · 7 Tage
hours_to_show: 168
entities:
- entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzte_partition
name: USB 1
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzte_partition
name: USB 2
grid_options:
columns: 12
rows: auto
- type: entities
title: USB-Laufwerk 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_usb_disk_1_status
name: Zustand
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzte_partition
name: Belegung
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzter_partitionsplatz
name: Belegter Speicher
- entity: sensor.new_syno_usb_disk_1_partition_1_partitionsgrosse
name: Gesamtkapazität
grid_options:
columns: 12
rows: auto
- type: entities
title: USB-Laufwerk 2
show_header_toggle: false
entities:
- entity: sensor.new_syno_usb_disk_2_status
name: Zustand
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzte_partition
name: Belegung
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzter_partitionsplatz
name: Belegter Speicher
- entity: sensor.new_syno_usb_disk_2_partition_1_partitionsgrosse
name: Gesamtkapazität
grid_options:
columns: 12
rows: auto
- title: OPNsense
path: opnsense
subview: true
back_path: "/dashboard-homelab/home"
icon: mdi:shield-lock
type: sections
max_columns: 3
dense_section_placement: false
header:
layout: start
card:
type: markdown
content: |-
# OPNsense · ALG
Firewall **192.168.1.250:8443** · Konfigurierte Version **26.7.7**
Messwerte aus der OPNsense-Integration. Netzwerkwerte in Mbit/s, Temperaturen ohne angenommene Hardware-Zuordnung.
sections:
- type: grid
cards:
- type: heading
heading: System
heading_style: title
icon: mdi:chip
- type: horizontal-stack
cards:
- type: gauge
entity: sensor.alg_cpu_usage
name: CPU
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 70
red: 90
- type: gauge
entity: sensor.alg_memory_used_percentage
name: RAM
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
grid_options:
columns: 12
rows: auto
- type: history-graph
title: CPU & RAM · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_cpu_usage
name: CPU
- entity: sensor.alg_memory_used_percentage
name: RAM
grid_options:
columns: 12
rows: auto
- type: history-graph
title: Temperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.alg_temp_zone_0
name: Zone 0
- entity: sensor.alg_temp_zone_1
name: Zone 1
grid_options:
columns: 12
rows: auto
- type: entities
title: Systemdetails
show_header_toggle: false
entities:
- entity: sensor.alg_system_boottime
name: Letzter Systemstart
- entity: sensor.alg_system_load_average_one_minute
name: Last · 1 Minute
- entity: sensor.alg_system_load_average_five_minute
name: Last · 5 Minuten
- entity: sensor.alg_system_load_average_fifteen_minute
name: Last · 15 Minuten
grid_options:
columns: 12
rows: auto
- type: gauge
entity: sensor.alg_filesystem_used_percentage_root
name: Systemspeicher · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: WAN · Internet
heading_style: title
icon: mdi:web
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_wan_traffic_in_rate
name: WAN eingehend
graph: line
detail: 2
hours_to_show: 6
icon: mdi:download-network
- type: sensor
entity: sensor.alg_interface_wan_traffic_out_rate
name: WAN ausgehend
graph: line
detail: 2
hours_to_show: 6
icon: mdi:upload-network
grid_options:
columns: 12
rows: auto
- type: history-graph
title: WAN-Durchsatz · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_wan_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_wan_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: entities
title: WAN & Gateways
show_header_toggle: false
entities:
- entity: sensor.alg_interface_wan_status
name: WAN-Verbindung
- entity: sensor.alg_gateway_wan_gw_status
name: WAN_GW
- entity: sensor.alg_gateway_alg_status
name: ALG
grid_options:
columns: 12
rows: auto
- type: history-graph
title: Gateway-Erreichbarkeit · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.alg_gateway_wan_gw_status
name: WAN_GW
- entity: sensor.alg_gateway_alg_status
name: ALG
grid_options:
columns: 12
rows: auto
- type: markdown
content: WAN eingehend entspricht der Download-Richtung, ausgehend der Upload-Richtung
aus Sicht der Firewall. Schnittstellenverkehr enthält auch Verkehr der Firewall
selbst.
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Status & Hinweise
heading_style: title
icon: mdi:shield-check
- type: conditional
conditions:
- condition: state
entity: sensor.alg_interface_lan_status
state: no carrier
card:
type: markdown
content: |-
### LAN · Kein Link
Die LAN-Schnittstelle meldet **no carrier**. Falls sie verwendet werden soll, Kabel, Gegenstelle und Port-Zuordnung prüfen. Bei einem ungenutzten Port kann dies erwartet sein.
grid_options:
columns: 12
rows: auto
- type: entities
title: Schnittstellen
show_header_toggle: false
entities:
- entity: sensor.alg_interface_wan_status
name: WAN
- entity: sensor.alg_interface_lan_status
name: LAN
- entity: sensor.alg_interface_dmz_status
name: DMZ
- entity: sensor.alg_interface_proxy_status
name: PROXY
- entity: sensor.alg_interface_transfer_status
name: TRANSFER
- entity: sensor.alg_interface_loopback_status
name: LOOPBACK
grid_options:
columns: 12
rows: auto
- type: entities
title: Meldungen & DHCP
show_header_toggle: false
entities:
- entity: binary_sensor.alg_pending_notices_present
name: Offene Systemmeldungen
- entity: sensor.alg_dhcp_leases_all
name: Gemeldete DHCP-Leases
grid_options:
columns: 12
rows: auto
- type: markdown
content: |-
**Firmware:** {% if is_state('update.alg_firmware_updates_available', 'on') %}Update verfügbar{% elif is_state('update.alg_firmware_updates_available', 'off') %}Kein Update gemeldet{% else %}Status unbekannt{% endif %}
DHCP-Wert 0 allein bestätigt nicht, dass keine Clients verbunden sind; die Anzeige hängt von der aktivierten DHCP-Abfrage ab.
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: LAN
heading_style: title
icon: mdi:ethernet
- type: entities
title: Verbindung
show_header_toggle: false
entities:
- entity: sensor.alg_interface_lan_status
name: Linkstatus
grid_options:
columns: 12
rows: auto
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_lan_traffic_in_rate
name: Eingehend
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.alg_interface_lan_traffic_out_rate
name: Ausgehend
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: LAN · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_lan_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_lan_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: DMZ
heading_style: title
icon: mdi:ethernet
- type: entities
title: Verbindung
show_header_toggle: false
entities:
- entity: sensor.alg_interface_dmz_status
name: Linkstatus
grid_options:
columns: 12
rows: auto
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_dmz_traffic_in_rate
name: Eingehend
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.alg_interface_dmz_traffic_out_rate
name: Ausgehend
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: DMZ · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_dmz_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_dmz_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: PROXY
heading_style: title
icon: mdi:ethernet
- type: entities
title: Verbindung
show_header_toggle: false
entities:
- entity: sensor.alg_interface_proxy_status
name: Linkstatus
grid_options:
columns: 12
rows: auto
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_proxy_traffic_in_rate
name: Eingehend
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.alg_interface_proxy_traffic_out_rate
name: Ausgehend
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: PROXY · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_proxy_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_proxy_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: TRANSFER
heading_style: title
icon: mdi:ethernet
- type: entities
title: Verbindung
show_header_toggle: false
entities:
- entity: sensor.alg_interface_transfer_status
name: Linkstatus
grid_options:
columns: 12
rows: auto
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_transfer_traffic_in_rate
name: Eingehend
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.alg_interface_transfer_traffic_out_rate
name: Ausgehend
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: TRANSFER · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_transfer_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_transfer_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Loopback
heading_style: title
icon: mdi:swap-horizontal
- type: entities
title: Interne Schnittstelle
show_header_toggle: false
entities:
- entity: sensor.alg_interface_loopback_status
name: Status
- entity: sensor.alg_interface_loopback_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_loopback_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
+21
View File
@@ -0,0 +1,21 @@
#!/bin/sh
# Install on DSM as root-owned /usr/local/sbin/ha-dns-gateway.sh.
# Only used as the forced command of the dedicated Home Assistant SSH key.
set -eu
case "${SSH_ORIGINAL_COMMAND:-}" in
check-dns)
test -x /usr/syno/bin/synopkg
test -d /var/packages/DNSServer
sudo -n -l /usr/syno/bin/synopkg restart DNSServer >/dev/null
printf '%s\n' 'DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.'
;;
restart-dns)
test -x /usr/syno/bin/synopkg
test -d /var/packages/DNSServer
exec sudo -n /usr/syno/bin/synopkg restart DNSServer
;;
*)
printf '%s\n' 'Nur check-dns oder restart-dns ist erlaubt.' >&2
exit 64
;;
esac
@@ -0,0 +1,3 @@
# DSM: confirmed includedir /etc/sudoers.d; visudo unavailable.
# See DNS-SETUP.md: create /etc/sudoers.d/ha-dns without overwriting (root:root, 0440).
Madzone ALL=(root) NOPASSWD: /usr/syno/bin/synopkg restart DNSServer
+48
View File
@@ -0,0 +1,48 @@
# Nach /config/packages/synology_dns.yaml kopieren.
shell_command:
synology_dns_restart: >-
ssh -F /dev/null -T -p 22
-i /config/ssh/synology_dns_ed25519
-o BatchMode=yes -o IdentitiesOnly=yes
-o StrictHostKeyChecking=yes
-o UserKnownHostsFile=/config/ssh/synology_dns_known_hosts
-o ConnectTimeout=10 -o ServerAliveInterval=5 -o ServerAliveCountMax=2
Madzone@192.168.1.230 restart-dns
script:
synology_dns_restart:
alias: Synology · DNS Server neu starten
icon: mdi:dns
mode: single
sequence:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS Server
message: Neustartbefehl wird gesendet …
- variables:
dns_result:
returncode: -1
- action: shell_command.synology_dns_restart
response_variable: dns_result
continue_on_error: true
- choose:
- conditions: "{{ dns_result is defined and dns_result is mapping and dns_result.get('returncode', -1) == 0 }}"
sequence:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS Server
message: >-
Der DNS-Neustartbefehl wurde erfolgreich ausgeführt.
Das NAS wurde nicht neu gestartet. Die DNS-Auflösung wurde nicht separat geprüft.
default:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS · Neustart nicht bestätigt
message: >-
SSH oder der Neustartbefehl ist fehlgeschlagen, oder das Zeitlimit wurde erreicht.
Prüfe den DNS-Paketstatus in DSM und das Home-Assistant-Protokoll,
bevor du einen weiteren Neustart auslöst.
- delay: '00:01:00'
+199
View File
@@ -0,0 +1,199 @@
#!/usr/bin/env python3
"""Local DSM collector and authenticated HOMELAB API. Python 3 standard library."""
import argparse
import glob
import hmac
import json
import os
from pathlib import Path
import re
import shutil
import subprocess
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
STATIC = Path(__file__).parent / 'static'
def read(path):
try:
return Path(path).read_text().strip()
except OSError:
return ''
def run(args):
try:
p = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
universal_newlines=True, timeout=25, env=dict(os.environ, LC_ALL='C'))
return p.returncode, p.stdout
except (OSError, subprocess.TimeoutExpired):
return -1, ''
def executable(name, paths):
return next((p for p in paths if os.access(p, os.X_OK)), shutil.which(name))
def smart(text, code):
match = re.search(r'(?:overall-health self-assessment test result|Health Status):\s*(.+)', text)
status = 'Unbekannt'
if match and code >= 0 and not code & 7:
status = 'OK' if match[1].strip() in ('PASSED', 'OK') else 'Warnung'
if code & 248:
status = 'Warnung'
temp = re.search(r'^\s*194\s+\S+\s+(?:\S+\s+){7}(\d+)', text, re.M)
if not temp:
temp = re.search(r'(?:Temperature|Current Drive Temperature):\s*(\d+)', text)
return {'status': status, 'temperature': int(temp[1]) if temp else None}
class Collector:
def __init__(self):
self.lock = threading.Lock()
self.previous = None
self.storage = {}
self.storage_time = 0
def disks_and_pools(self):
disks = []
binary = executable('smartctl', ['/usr/syno/bin/smartctl', '/usr/sbin/smartctl'])
for path in sorted(glob.glob('/sys/block/*')):
name = Path(path).name
if not re.fullmatch(r'(sd[a-z]+|sata\d+|nvme\d+n\d+)', name):
continue
code, output = run([binary, '-n', 'standby', '-a', '/dev/' + name]) if binary else (-1, '')
disks.append(dict(name=name, model=read(path + '/device/model') or name, **smart(output, code)))
raids = []
for path in sorted(glob.glob('/sys/block/md*/md')):
name = Path(path).parent.name
if name in ('md0', 'md1'):
continue
degraded = read(path + '/degraded')
raids.append({'name': name, 'level': read(path + '/level'),
'status': ('Warnung' if int(degraded) else 'OK') if degraded.isdigit() else 'Unbekannt',
'action': read(path + '/sync_action') or 'Unbekannt'})
pools = []
vgs = executable('vgs', ['/sbin/vgs', '/usr/sbin/vgs'])
if vgs:
code, output = run([vgs, '--noheadings', '--units', 'b', '--nosuffix', '--separator', '|', '-o', 'vg_name,vg_size,vg_free'])
if code == 0:
for line in output.splitlines():
fields = line.strip().split('|')
try:
pools.append({'name': fields[0].strip(), 'total': float(fields[1]), 'free': float(fields[2])})
except (ValueError, IndexError):
pass
volumes = []
for path in sorted(glob.glob('/volume[0-9]*')):
if not re.fullmatch(r'/volume\d+', path) or not os.path.ismount(path):
continue
usage = shutil.disk_usage(path)
volumes.append(dict(name=path, total=usage.total, free=usage.free))
return dict(disks=disks, raids=raids, pools=pools, volumes=volumes)
def sample(self):
with self.lock:
now = time.monotonic()
cpu_line = read('/proc/stat').splitlines()
cpu = [int(x) for x in cpu_line[0].split()[1:9]] if cpu_line else []
net = {}
for path in sorted(glob.glob('/sys/class/net/*')):
name = Path(path).name
# Physical links only: avoids counting bonds/bridges and members twice.
if not os.path.exists(path + '/device'):
continue
rx, tx = read(path + '/statistics/rx_bytes'), read(path + '/statistics/tx_bytes')
if rx.isdigit() and tx.isdigit():
net[name] = (int(rx), int(tx), read(path + '/operstate'))
load, interfaces = None, []
if self.previous:
before, old_cpu, old_net = self.previous
if cpu and old_cpu:
total = sum(cpu) - sum(old_cpu)
idle = sum(cpu[3:5]) - sum(old_cpu[3:5])
load = round(max(0, min(100, 100 * (1 - idle / total))), 1) if total > 0 else None
for name, (rx, tx, state) in net.items():
old = old_net.get(name)
interfaces.append(dict(name=name, status=state,
down=max(0, rx-old[0]) / (now-before) if old else None,
up=max(0, tx-old[1]) / (now-before) if old else None))
else:
interfaces = [dict(name=n, status=v[2], down=None, up=None) for n,v in net.items()]
self.previous = now, cpu, net
mem = dict((k, int(v)*1024) for k,v in re.findall(r'^(\w+):\s+(\d+)', read('/proc/meminfo'), re.M))
ram = dict(total=mem.get('MemTotal'), free=mem.get('MemAvailable'))
if now-self.storage_time > 60 or not self.storage:
self.storage = self.disks_and_pools()
self.storage_time = now
dns_pid = read('/var/packages/DNSServer/target/var/named.pid')
dns = 'Läuft' if dns_pid.isdigit() and Path('/proc/' + dns_pid).exists() else 'Unbekannt'
return dict(cpu=load, ram=ram, interfaces=interfaces, dns=dns,
timestamp=time.time(), storage_age=round(now-self.storage_time), **self.storage)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--host', default='127.0.0.1')
parser.add_argument('--port', type=int, default=8787)
parser.add_argument('--demo', action='store_true')
args = parser.parse_args()
token = os.environ.get('HOMELAB_TOKEN', '')
if not args.demo and len(token) < 24:
parser.error('HOMELAB_TOKEN muss mindestens 24 Zeichen enthalten.')
collector = Collector()
restart_lock = threading.Lock()
last_restart = [0]
class Handler(BaseHTTPRequestHandler):
def reply(self, status, data, kind='application/json'):
body = json.dumps(data).encode() if kind == 'application/json' else data
self.send_response(status)
self.send_header('Content-Type', kind + '; charset=utf-8')
self.send_header('Content-Length', str(len(body)))
self.send_header('Cache-Control', 'no-store')
self.send_header('X-Content-Type-Options', 'nosniff')
self.send_header('Content-Security-Policy', "default-src 'self'; script-src 'self'; style-src 'self'; frame-ancestors 'none'; base-uri 'none'")
self.end_headers()
self.wfile.write(body)
def authorized(self):
return hmac.compare_digest(self.headers.get('Authorization', ''), 'Bearer ' + token) and bool(token)
def do_GET(self):
if self.path == '/api/status':
if args.demo:
return self.reply(200, {'demo': True})
if not self.authorized():
return self.reply(401, {'error': 'Zugriffsschlüssel erforderlich.'})
try:
data = collector.sample()
data['can_restart'] = os.environ.get('HOMELAB_ALLOW_DNS_RESTART') == '1'
return self.reply(200, data)
except Exception:
return self.reply(503, {'error': 'Messwerte konnten nicht gelesen werden.'})
files = {'/': ('index.html','text/html'), '/dsm': ('index.html','text/html'),
'/app.js': ('app.js','text/javascript'), '/style.css': ('style.css','text/css')}
if self.path not in files:
return self.reply(404, {'error': 'Nicht gefunden'})
name, kind = files[self.path]
self.reply(200, (STATIC/name).read_bytes(), kind)
def do_POST(self):
if self.path != '/api/dns/restart':
return self.reply(404, {'error': 'Nicht gefunden'})
if args.demo or not self.authorized():
return self.reply(403, {'error': 'Neustart nicht freigegeben.'})
if os.environ.get('HOMELAB_ALLOW_DNS_RESTART') != '1':
return self.reply(403, {'error': 'DNS-Neustart muss auf dem NAS aktiviert werden.'})
if not restart_lock.acquire(blocking=False):
return self.reply(409, {'error': 'Neustart läuft bereits.'})
try:
if time.monotonic()-last_restart[0] < 60:
return self.reply(429, {'error': 'Bitte 60 Sekunden zwischen Neustarts warten.'})
last_restart[0] = time.monotonic()
code, _ = run(['/usr/syno/bin/synopkg', 'restart', 'DNSServer'])
self.reply(200 if code == 0 else 503, {'message': 'Neustartbefehl erfolgreich ausgeführt. Dienststatus in DSM prüfen.'} if code == 0 else {'error': 'Neustart fehlgeschlagen oder Zeitlimit erreicht. Dienststatus in DSM prüfen.'})
finally:
restart_lock.release()
httpd = ThreadingHTTPServer((args.host, args.port), Handler)
print('HOMELAB: http://%s:%s%s' % (args.host, args.port, ' (DEMO)' if args.demo else ''), flush=True)
httpd.serve_forever()
if __name__ == '__main__':
main()
+30
View File
@@ -0,0 +1,30 @@
'use strict';
const $ = id => document.getElementById(id);
const isDSM = location.pathname === '/dsm';
$('home').hidden = isDSM; $('dsm').hidden = !isDSM;
$(isDSM ? 'dsm-nav' : 'home-nav').classList.add('active');
$('breadcrumb').textContent = isDSM ? 'DSM' : 'Übersicht';
let token = '', demo = false, busy = false, restarting = false, canRestart = false;
const history = {down: [], up: []};
const number = n => n.toLocaleString('de-DE', {maximumFractionDigits: 1});
const bytes = n => {if(n == null) return '—'; const unit = n >= 2**40 ? [2**40,'TiB'] : n >= 2**30 ? [2**30,'GiB'] : n >= 2**20 ? [2**20,'MiB'] : [1024,'KiB']; return `${number(n/unit[0])} ${unit[1]}`;};
const escape = s => String(s).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
function fixture(){return {cpu:18.4,ram:{total:8*2**30,free:5.2*2**30},interfaces:[{name:'eth0',status:'up',down:24.8*2**20,up:6.3*2**20},{name:'eth1',status:'down',down:0,up:0}],pools:[{name:'vg1000',total:32*2**40,free:4*2**40}],volumes:[{name:'/volume1',total:28*2**40,free:12.6*2**40}],raids:[{name:'md2',level:'raid6',status:'OK',action:'idle'}],disks:Array.from({length:8},(_,i)=>({name:`sata${i+1}`,model:'Beispiellaufwerk · 8 TB',status:'OK',temperature:32+i%4})),dns:'Demo · Läuft',timestamp:Date.now()/1000,storage_age:0};}
function chart(key, color){const c=$(key+'-chart'),ctx=c.getContext('2d'),arr=history[key];ctx.clearRect(0,0,c.width,c.height); if(arr.length<2)return;const max=Math.max(...arr,1);ctx.beginPath();arr.forEach((v,i)=>{const x=i*300/59,y=44-v/max*38;i?ctx.lineTo(x,y):ctx.moveTo(x,y);});ctx.strokeStyle=color;ctx.lineWidth=2;ctx.stroke();}
function render(d){
$('cpu').textContent=d.cpu==null?'—':number(d.cpu)+' %';$('cpu-bar').value=d.cpu||0;
const ram=d.ram.total&&d.ram.free!=null?100*(1-d.ram.free/d.ram.total):null;
$('ram').textContent=ram==null?'—':number(ram)+' %';$('ram-bar').value=ram||0;
$('ram-detail').textContent=ram==null?'Nicht verfügbar':`${bytes(d.ram.total-d.ram.free)} von ${bytes(d.ram.total)}`;
for(const [key,id,color] of [['down','download','#65dfb3'],['up','upload','#80b6ff']]){const measured=d.interfaces.filter(n=>n[key]!=null);const sum=measured.length?measured.reduce((a,n)=>a+n[key],0):null;$(id).textContent=sum==null?'—':bytes(sum)+'/s';if(sum!=null){history[key].push(sum);if(history[key].length>60)history[key].shift();}chart(key,color);}
$('network').innerHTML=d.interfaces.map(n=>`<div class="network-row"><div>${escape(n.name)}<small class="${n.status==='up'?'ok':'warn'}">${escape(n.status==='up'?'Verbunden':n.status==='down'?'Getrennt':n.status)}</small></div><div>↓ ${bytes(n.down)}/s<small>↑ ${bytes(n.up)}/s</small></div></div>`).join('')||'<p class="quiet">Keine physischen Schnittstellen verfügbar.</p>';
$('storage').innerHTML=[...d.pools.map(p=>({...p,label:'Pool / LVM'})),...d.volumes.map(p=>({...p,label:'Volume'}))].map(p=>`<div class="storage-row"><div class="row"><span>${escape(p.name)}</span><small>${p.label}</small></div><progress max="100" value="${p.total?100*(1-p.free/p.total):0}"></progress><div class="row"><small>${bytes(p.total-p.free)} von ${bytes(p.total)}</small><small>${bytes(p.free)} frei</small></div></div>`).join('')+(d.pools.length?'':'<p class="quiet">Pool-Kapazität nicht verfügbar.</p>')+d.raids.map(r=>`<p class="quiet">${escape(r.name)} · ${escape(r.level)} · <span class="${r.status==='OK'?'ok':'warn'}">${escape(r.status)}</span> · ${escape(r.action)}</p>`).join('');
$('disks').innerHTML=d.disks.map(x=>`<tr><td>${escape(x.name)}</td><td>${escape(x.model)}</td><td class="${x.status==='OK'?'ok':'warn'}">${escape(x.status)}</td><td>${x.temperature==null?'—':escape(x.temperature)+' °C'}</td></tr>`).join('')||'<tr><td colspan="4">Keine Laufwerksdaten verfügbar.</td></tr>';
$('dns-status').textContent=d.dns;$('updated').textContent=new Date(d.timestamp*1000).toLocaleTimeString('de-DE');
canRestart=!!d.can_restart; $('restart').disabled=demo||restarting||!canRestart;
}
async function refresh(){if(busy)return;busy=true;try{const response=await fetch('/api/status',{headers:{Authorization:'Bearer '+token},signal:AbortSignal.timeout(90000)});if(response.status===401){$('login').hidden=false;throw Error('Verbinde dein NAS mit dem Zugriffsschlüssel.');}if(!response.ok)throw Error('Messwerte konnten nicht geladen werden.');let data=await response.json();demo=!!data.demo;if(demo)data=fixture();$('connection').textContent=demo?'DEMO · Beispieldaten':'LIVE · Verbunden';$('notice').textContent=demo?'VORSCHAU · Alle Werte sind Beispieldaten. Es besteht keine Verbindung zu deinem NAS. DNS-Neustart ist deaktiviert.':'';$('login').hidden=true;render(data);}catch(e){$('connection').textContent='Nicht verbunden';$('notice').textContent=e.message+' Angezeigte Werte sind gegebenenfalls veraltet.';$('restart').disabled=true;}finally{busy=false;}}
$('login-form').addEventListener('submit',e=>{e.preventDefault();token=$('token').value;$('token').value='';refresh();});
$('restart').onclick=()=>$('confirm').showModal();$('cancel').onclick=()=>$('confirm').close();
$('confirm-restart').onclick=async()=>{$('confirm').close();restarting=true;$('restart').disabled=true;$('dns-status').textContent='Neustart läuft …';try{const r=await fetch('/api/dns/restart',{method:'POST',headers:{Authorization:'Bearer '+token},signal:AbortSignal.timeout(30000)});const data=await r.json();$('action-result').textContent=data.message||data.error;}catch(e){$('action-result').textContent='Keine Bestätigung erhalten. DNS-Status in DSM prüfen, bevor du erneut startest.';}finally{restarting=false;$('restart').disabled=demo||!canRestart;}};
refresh();setInterval(refresh,5000);
+10
View File
@@ -0,0 +1,10 @@
<!doctype html>
<html lang="de"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>HOMELAB · DSM</title><link rel="stylesheet" href="/style.css"><script src="/app.js" defer></script></head>
<body><aside><a class="brand" href="/">▦ <span>HOMELAB<small>DEIN NETZWERK. EIN BLICK.</small></span></a><div class="nav-label">WORKSPACE</div><nav><a href="/" id="home-nav">⌂ &nbsp; Übersicht</a><a href="/dsm" id="dsm-nav">▤ &nbsp; DSM <span class="dot"></span></a></nav><div class="side-bottom"><span class="dot"></span> Lokales Dashboard<br><small>Synology DS1817+ · DSM 7.3.2<br>Konfigurierte Zielplattform</small></div></aside>
<main><header><span>Workspace <b>/</b> <span id="breadcrumb">Übersicht</span></span><span id="connection" class="badge">Verbinde …</span></header><div id="notice" role="status"></div><section id="login" hidden><form id="login-form"><label for="token">Zugriffsschlüssel für dein NAS</label><div class="login-row"><input id="token" type="password" autocomplete="off" required placeholder="HOMELAB-Zugriffsschlüssel"><button>Verbinden</button></div><small>Der Schlüssel bleibt nur für diese geöffnete Seite im Arbeitsspeicher.</small></form></section>
<section id="home"><div class="eyebrow">DEINE INFRASTRUKTUR</div><h1>Alles an einem Ort.</h1><p class="subtitle">Dein Homelab. Klar im Blick.</p><a class="service" href="/dsm"><div class="service-icon">▤</div><div><div class="eyebrow">STORAGE & SERVICES</div><h2>Synology DSM</h2><p>DS1817+ <span>·</span> DSM 7.3.2</p><div class="tags"><span>Netzwerk</span><span>Speicher</span><span>System</span></div></div><span class="arrow">↗</span></a><p class="quiet">Öffne DSM für Live-Messwerte, Laufwerkszustand und DNS-Verwaltung.</p></section>
<section id="dsm" hidden><div class="title-row"><div><div class="eyebrow">SYNOLOGY · DS1817+</div><h1>DiskStation</h1><p class="subtitle">System, Speicher und Netzwerk im Überblick.</p></div><div class="updated">Aktualisiert alle 5 Sekunden<br><span id="updated">Noch keine Daten</span></div></div><div class="metrics"><article><div class="card-label">CPU-AUSLASTUNG <span>◉</span></div><div class="value" id="cpu">—</div><progress id="cpu-bar" max="100" value="0"></progress><small>Aktuelle Prozessorauslastung</small></article><article><div class="card-label">ARBEITSSPEICHER <span>▥</span></div><div class="value" id="ram">—</div><progress id="ram-bar" max="100" value="0"></progress><small id="ram-detail">Noch keine Daten</small></article><article><div class="card-label">DOWNLOAD <span class="mint">↓</span></div><div class="value mint" id="download">—</div><canvas id="down-chart" width="300" height="48" aria-label="Download-Verlauf"></canvas><small>Summe physischer Netzwerkschnittstellen</small></article><article><div class="card-label">UPLOAD <span class="blue">↑</span></div><div class="value blue" id="upload">—</div><canvas id="up-chart" width="300" height="48" aria-label="Upload-Verlauf"></canvas><small>Summe physischer Netzwerkschnittstellen</small></article></div>
<div class="columns"><article><div class="section-head"><h2>Speicher</h2><span class="badge">Pools & Volumes</span></div><div id="storage"></div><p class="quiet">Pool: zugewiesener Speicher · Volume: belegter Speicher</p></article><article><div class="section-head"><h2>Netzwerk</h2><span class="badge">Schnittstellen</span></div><div id="network"></div></article></div>
<article class="disk-panel"><div class="section-head"><h2>Festplatten</h2><span class="badge">SMART</span></div><div class="table-wrap"><table><thead><tr><th>Laufwerk</th><th>Modell</th><th>SMART-Zustand</th><th>Temperatur</th></tr></thead><tbody id="disks"></tbody></table></div><p class="quiet" id="smart-age">SMART wird alle 60 Sekunden gelesen; schlafende Laufwerke werden nicht geweckt.</p></article>
<article class="dns"><div class="dns-icon">⌘</div><div><h2>DNS Server</h2><p id="dns-status">Status unbekannt</p></div><button id="restart" disabled>↻ &nbsp; DNS Server neu starten</button></article><p id="action-result" role="status"></p><p class="quiet">Netzwerkwerte zeigen den Datenverkehr des NAS, nicht den gesamten Internetanschluss.</p></section><footer>HOMELAB <span>Privat. Lokal. Unter deiner Kontrolle.</span></footer></main>
<dialog id="confirm"><h2>DNS Server neu starten?</h2><p>Die Namensauflösung kann dabei kurzzeitig ausfallen.</p><div class="dialog-buttons"><button id="cancel">Abbrechen</button><button id="confirm-restart">Jetzt neu starten</button></div></dialog></body></html>
File diff suppressed because one or more lines are too long
+27
View File
@@ -0,0 +1,27 @@
import importlib.util
from pathlib import Path
import unittest
spec = importlib.util.spec_from_file_location('server', Path(__file__).resolve().parents[1] / 'server.py')
server = importlib.util.module_from_spec(spec)
spec.loader.exec_module(server)
class SmartTests(unittest.TestCase):
def test_passed(self):
self.assertEqual(server.smart('SMART overall-health self-assessment test result: PASSED', 0)['status'], 'OK')
def test_failed_command_is_not_healthy(self):
self.assertEqual(server.smart('SMART overall-health self-assessment test result: PASSED', 2)['status'], 'Unbekannt')
def test_historical_errors_warn(self):
self.assertEqual(server.smart('SMART overall-health self-assessment test result: PASSED', 64)['status'], 'Warnung')
def test_sleeping_drive_unknown(self):
self.assertEqual(server.smart('Device is in STANDBY mode', 2)['status'], 'Unbekannt')
def test_temperature(self):
result = server.smart('194 Temperature_Celsius 0x0022 020 020 000 Old_age Always - 32 (Min/Max 19/42)', 0)
self.assertEqual(result['temperature'], 32)
if __name__ == '__main__':
unittest.main()
+170
View File
@@ -0,0 +1,170 @@
# Korrigierte Kopie: alle acht Optionen
Datei: `NDTrack-Geprueft.ps1`, Version **1.0.3** (2026-10-15). Das Original und die vorherige Fassung bleiben unverändert.
## Vor dem Einsatz
Auf dem Mac bearbeiten, auf einem Windows-Verwaltungsrechner mit Windows PowerShell 5.1 oder geeigneter Windows-PowerShell-Umgebung ausführen. AD-Zugriff und WinRM-Berechtigungen werden benötigt. Linux benötigt SSH und SCP im Suchpfad. Die bisherige RDS-Option ist nicht mehr im Menü; die alten Hilfsfunktionen bleiben unaufgerufen erhalten. Das Skript ändert keine Ausführungsrichtlinien oder Serverkonfigurationen.
Ablage auf dem ausführenden Windows-Verwaltungsrechner:
```text
C:\SCAN\SCRIPT\PreScript.ps1
C:\SCAN\SCRIPT\NDTrack-Geprueft.ps1
C:\SCAN\SCRIPT\Logs\
C:\SCAN\NDTRACK\RunNdTrackWindows_Local.cmd
C:\SCAN\NDTRACK\RunNdTrackLinuxUnix_Local.sh
C:\SCAN\RESULTS\
```
Das Skript vom Mac nach `C:\SCAN\SCRIPT` kopieren. Die vollständigen NDTrack-Pakete liegen unter `C:\SCAN\NDTRACK`; für Linux wird die SH-Datei nur bei Verwendung der Linux-Optionen benötigt. Bei gleichnamigen, unterschiedlichen Paketdateien separate Quellunterordner verwenden und die beiden Quellpfade entsprechend anpassen. Beim empfohlenen Start über das PreScript müssen SCRIPT-, NDTRACK-, RESULTS- und Logordner bereits vorhanden sein: Das PreScript prüft nur und legt nichts an. Das Hauptskript besitzt zusätzlich eine eigene Ordnerprüfung, die bei direktem Start fehlende Ordner anlegen kann. Existiert unter einem dieser Pfade eine Datei statt eines Ordners, wird abgebrochen. Anschließend muss NDTRACK mindestens eine Datei enthalten (Unterordner werden mit durchsucht); andernfalls endet das Skript vor dem Menü mit einem Hinweis zum Ablegen des Pakets. Vor der Windows- oder Linux-Verteilung wird zusätzlich geprüft, ob die jeweils benötigte CMD-/SH-Startdatei vorhanden und nicht leer ist. Die Prüfung bewertet nicht die Vollständigkeit oder Funktionsfähigkeit aller Paketdateien. Der ausführende Benutzer braucht dort Schreibrechte. Die Pfade sind jetzt bewusst unabhängig vom Benutzerprofil.
In `Initialize-Configuration` konfiguriert:
- `SourcePath`: `C:\SCAN\NDTRACK` mit dem vollständigen Windows-NDTrack-Paket.
- `LinuxSourcePath`: `C:\SCAN\NDTRACK` mit dem vollständigen Linux-Paket. Die Startdatei muss eine gültige Shebang und Unix-Zeilenenden besitzen. Benötigte Binärdateien müssen für das Zielsystem passen und ausführbar sein.
- `TestServers`: zunächst eigene Windows-Testserver eintragen. Leer verwendet die Windows-Option die Serverauswahl aus dem AD. Linux-Ziele kommen separat aus einer Textdatei mit einem DNS-Namen oder einer IPv4-Adresse pro Zeile; Leerzeilen und Zeilen mit führendem # werden ignoriert.
- `DestinationPath`: standardmäßig leer; Systemlaufwerk automatisch per WMI/DCOM. `ServerDestinationPaths` ist nur für optionale Ausnahmen. Option 1 kopiert wie im Original über administrative Freigaben. Option 2 verwendet Task-Scheduler-RPC und schtasks.exe; Optionen 3 und 7 verwenden weiterhin WinRM. Die Löschfunktion akzeptiert nur einen dedizierten Ordner mit dem Namen ndtrack.
- Die alten RDS-Hilfsfunktionen werden von keinem Menüpunkt aufgerufen. Option 8 ist ausschließlich das Aufräumen auf Linux.
Die CMD-/SH-Startdateien wurden nicht mitgeliefert. Sie müssen synchron bis zum Scan-Ende laufen, einen sinnvollen Exitcode zurückgeben und ihre Inventare unter dem jeweiligen ndtrack/inventory ablegen. Eine Startdatei, die einen Prozess nur im Hintergrund startet oder Fehler verschluckt, kann das übergeordnete Skript nicht zuverlässig bewerten.
## Ausführen
Empfohlener Start in Windows PowerShell über die Vorprüfung:
```powershell
Set-Location 'C:\SCAN\SCRIPT'
.\PreScript.ps1 -Platform Windows
```
1. Windows: NDTrack-Dateien auf die AD-Server kopieren. Startet keinen Scan.
2. Windows: Task NDTRACK mit dem eingegebenen Benutzerkonto über den ursprünglichen schtasks.exe-Aufruf erstellen. Einmaliger Start nach fünf Minuten, kein sofortiger /Run-Aufruf. CMD muss aus Option 1 vorhanden sein. Kein XML, kein SYSTEM, kein WinRM. Wie im Original überschreibt /F einen vorhandenen Task; nur bei nicht laufendem Scan verwenden.
3. Windows: vorhandene Scan-Dateien nach C:\SCAN\RESULTS holen. Aktive bzw. fehlerhafte Tasks verhindern das Einsammeln.
4. Linux: NDTrack-Dateien über SCP kopieren. Startet keinen Scan.
5. Linux: zuvor bereitgestellten Scan per SSH starten und auf Abschluss warten. Verwendet keinen Windows-Scheduled-Task.
6. Linux: vorhandene Scan-Dateien nach C:\SCAN\RESULTS holen.
7. Windows: Task NDTRACK stoppen/entfernen, danach den NDTrack-Ordner löschen. Bei Fehlern beim Entfernen des Tasks keine Dateilöschung.
8. Linux: NDTrack-Ordner entfernen, sofern keine Scan-Sperre oder erkannter laufender ndtrack-Prozess besteht.
0. Beenden.
Ergebnisse liegen unter `C:\SCAN\RESULTS`, Protokolle unter `C:\SCAN\SCRIPT\Logs` auf dem ausführenden Rechner. Das Task-Konto ist davon unabhängig. Auf den entfernten Windows-Servern wird standardmäßig `<Systemlaufwerk>\ndtrack` automatisch per WMI/DCOM ermittelt. Jede Sammlung erzeugt einen separaten Ordner und überschreibt keine vorherigen Sammlungen. Das Alter der gesammelten Inventardateien wird ausdrücklich nicht bewertet.
Eine `.ndtrack-running`-Sperre wird für direkte Scans angelegt und normalerweise entfernt. Nach einem Verbindungs-/Systemabbruch kann sie zurückbleiben. Erst den tatsächlichen Prozesszustand prüfen und dann eine verwaiste Sperre manuell entfernen. Extern gestartete Scans oder gleichzeitig gestartete Skriptinstanzen können nicht vollständig ausgeschlossen werden; das Skript bietet keine transaktionale Sperre über Verteilung, Task und Sammlung hinweg.
## Einsatz in unterschiedlichen AD-Domänen
Das Hauptskript enthält keine fest vorgegebene Kundendomäne. Bei leeren Werten für `TargetDomain` und `DomainController` verwendet es `USERDNSDOMAIN`, also die DNS-Domäne des ausführenden Windows-Benutzers. Die Suchbasis wird aus dem AD selbst ermittelt. Es werden aktivierte Windows-Server der ausgewählten Domäne über ihre vollständigen DNS-Hostnamen angesprochen. Es erfolgt keine automatische Suche über alle Domänen einer Gesamtstruktur.
Für eine andere Domäne in `Initialize-Configuration` setzen, zum Beispiel:
```powershell
$script:TargetDomain = 'firma.example'
$script:DomainController = ''
```
Optional einen bestimmten DC angeben:
```powershell
$script:TargetDomain = 'firma.example'
$script:DomainController = 'dc01.firma.example'
```
Die Namen sind Beispiele und müssen durch die tatsächlichen DNS-Namen ersetzt werden. Bei beiden Angaben prüft das Skript, ob der DC zur angegebenen Domäne gehört. Ohne automatisch erkennbare Benutzerdomäne und ohne explizite Konfiguration bricht die AD-Auswahl mit einem Hinweis ab. Eine explizite `TestServers`-Liste umgeht die AD-Suche.
AD-Abfrage und WinRM verwenden das aktuelle Windows-Konto. Option 2 fragt das Ausführungskonto für den Task ab; Remote-Verwaltung erfolgt weiterhin mit dem aktuell angemeldeten Windows-Konto. DNS, Netzwerkzugriff und Berechtigungen müssen in der Zieldomäne vorhanden sein. Bei nicht vertrauenswürdigen Domänen reicht die Angabe des Domänennamens allein nicht; das Skript richtet keine Vertrauensstellung oder alternative WinRM-Anmeldung ein. Es kann auf einem passend berechtigten Verwaltungsrechner der jeweiligen Domäne verwendet werden. Linux-Ziele bleiben unabhängig davon in der Textdatei definiert.
Sieben isolierte Tests der Domänenauswahl bestanden; echte domänenübergreifende AD-/WinRM-Verbindungen wurden nicht getestet. Test: `pwsh -NoProfile -File ./NDTrack/tests/Test-DomainSelection.ps1`.
## Dynamischer Zielpfad ohne WinRM beim Kopieren
`$script:DestinationPath = ''` ist die Standardeinstellung. Das Systemlaufwerk wird pro Windows-Zielserver aus `Win32_OperatingSystem.SystemDrive` über eine ausdrücklich auf DCOM eingestellte CIM-Verbindung ermittelt. Option 1 verwendet anschließend SMB für die Dateiübertragung:
| Systemlaufwerk des Servers | Lokaler Zielordner | Kopierfreigabe |
|---|---|---|
| C: | `C:\ndtrack` | `\\SERVER\C$\ndtrack` |
| D: | `D:\ndtrack` | `\\SERVER\D$\ndtrack` |
| E: | `E:\ndtrack` | `\\SERVER\E$\ndtrack` |
Für einen SQL-Server ohne C: mit Windows auf D: wird damit automatisch D:\ndtrack verwendet. Maßgeblich ist das Windows-Systemlaufwerk, nicht das SQL-Datenlaufwerk. Es muss keine Serverliste mit Laufwerkszuordnungen gepflegt werden. `ServerDestinationPaths` bleibt standardmäßig leer und dient ausschließlich optionalen Ausnahmen; ein expliziter DestinationPath überschreibt die automatische Ermittlung.
Voraussetzungen für Option 1: WMI/DCOM-Zugriff zur Laufwerksermittlung sowie Zugriff auf die administrative Freigabe mit dem aktuellen Windows-Konto. WinRM wird von Option 1 nicht verwendet. Ist die WMI-Abfrage oder die Freigabe nicht erreichbar, wird der Server mit einer Warnung übersprungen; das Skript rät kein Ersatzlaufwerk. Firewall-, DCOM- und Berechtigungseinstellungen werden nicht automatisch verändert.
Der Zielordner wird über die Freigabe angelegt. Eine vorhandene Scan-Sperre verhindert das Kopieren; der Task-Zustand wird hier nicht per WinRM geprüft. Option 1 nur ausführen, wenn kein Scan läuft. Option 2 verwendet ebenfalls kein WinRM mehr: ursprünglicher schtasks.exe /Create-Aufruf mit Benutzerkonto und einmaligem Start nach fünf Minuten. Optionen 3 und 7 verwenden weiterhin WinRM. Alle verwenden denselben ermittelten Zielpfad.
Die CMD-Datei muss ohne fest eingebautes C:\ndtrack funktionieren. Ihre internen Pfade wurden nicht geprüft. Die festen C:\SCAN-Pfade gelten ausschließlich für den Verwaltungsrechner. Alte Installationen werden nicht automatisch migriert.
Die simulierten Tests decken unterschiedliche Laufwerke, fehlende Freigaben, WMI-Fehler und das Schließen der CIM-Verbindungen ab. Ein echter Zielservertest steht aus; der zuvor gemeldete Anmeldefehler ist damit noch nicht nachweislich behoben.
## Prüfung und Grenzen
- PowerShell-Syntax geprüft.
- Alle acht Menüabläufe isoliert getestet.
- Geprüft: getrennte Menüaktionen für Kopieren, Starten und Einsammeln; Task-Entfernung vor Dateilöschung; native Exitcodes; Task-Aufruf ohne Kontoabfrage; Standardzielpfad und explizite Zielpfade pro Server; Ablehnung ungültiger Hostnamen/Pfadsegmente.
- Fehlerpfade mit simulierten Remote-/SSH-Fehlern geprüft: Warnung statt falscher Erfolgsmeldung.
- Aktuelle Menü-/Fehlerprüfungen: 41 bestanden. Zusätzlich 4 simulierte Task-Start-Szenarien für schtasks.exe bestanden. Ordner-/Datei- und PreScript-Tests liegen separat vor.
- Keine echten AD-, Windows-, RDS- oder Linux-Zielsysteme getestet. Die Tests ersetzen keinen Abnahmelauf mit den tatsächlichen NDTrack-Dateien.
Tests auf Mac oder Windows mit PowerShell:
```powershell
pwsh -NoProfile -File ./NDTrack/tests/Test-NDTrack.ps1
pwsh -NoProfile -File ./NDTrack/tests/Test-SourceFolders.ps1
```
Der Befehl gilt aus dem Repository-Hauptordner. Die Tests führen ausschließlich lokale PowerShell-Kindprozesse und Simulationen aus; keine Zielserverzugriffe.
## Git im bestehenden Repository
```bash
cd '/Users/michaeltroebs/Documents/GIT/syno-scripts'
git status --short
git add NDTrack/NDTrack-Geprueft.ps1 NDTrack/ANLEITUNG-Geprueft.md NDTrack/tests/Test-NDTrack.ps1 NDTrack/tests/Test-SourceFolders.ps1
git diff --cached -- NDTrack/NDTrack-Geprueft.ps1 NDTrack/ANLEITUNG-Geprueft.md NDTrack/tests/Test-NDTrack.ps1 NDTrack/tests/Test-SourceFolders.ps1
git commit -m "NDTrack: alle acht Ablaeufe und Fehlerbehandlung korrigieren" -- NDTrack/NDTrack-Geprueft.ps1 NDTrack/ANLEITUNG-Geprueft.md NDTrack/tests/Test-NDTrack.ps1 NDTrack/tests/Test-SourceFolders.ps1
```
Es wurde von Codex nichts vorgemerkt, committed oder hochgeladen.
## Separates PreScript
`PreScript.ps1` prüft ausschließlich vorhandene Ordner und Dateien. Es legt keine Ordner an und kopiert keine Dateien. Vorab bereitstellen:
- `C:\SCAN\SCRIPT` mit PreScript.ps1 und NDTrack-Geprueft.ps1
- `C:\SCAN\SCRIPT\Logs`
- `C:\SCAN\NDTRACK` mit dem vollständigen NDTrack-Paket
- `C:\SCAN\RESULTS`
```powershell
Set-Location 'C:\SCAN\SCRIPT'
.\PreScript.ps1 -Platform Windows
```
Für beide Pakete `-Platform Both`, für Linux `-Platform Linux`. Bei erfolgreicher Prüfung startet das PreScript automatisch das Hauptskript und damit dessen Menü. Eine Scan-Option wird nicht automatisch ausgewählt. Bei fehlenden Ordnern, fehlenden Dateien, leeren Startdateien oder Syntaxfehlern im Hauptskript wird abgebrochen; das Hauptskript startet nicht.
Die Prüfung bestätigt nicht die vollständige Paketintegrität oder die Erreichbarkeit der Zielserver. Das gestartete Hauptskript besitzt weiterhin seine eigenen Prüfungen und führt erst nach der Menüauswahl die entsprechende Aktion aus.
`-BasePath` dient isolierten Tests und ändert nicht die Konfiguration des Hauptskripts. Sechs Szenarien wurden mit temporären Dateien und einem harmlosen Test-Hauptskript erfolgreich geprüft, einschließlich automatischem Start und Verzicht auf Ordneranlage:
```powershell
pwsh -NoProfile -File ./NDTrack/tests/Test-PreScript.ps1
```
Zusätzliche Dateien für Git: `NDTrack/PreScript.ps1` und `NDTrack/tests/Test-PreScript.ps1`.
Nach Umstieg wird ausschließlich der Task NDTRACK verwendet. Ein alter Task NDTrackTask aus einer früheren Version wird nicht automatisch migriert oder entfernt.
Task-Start-Test: `pwsh -NoProfile -File ./NDTrack/tests/Test-TaskStart.ps1`. Auch diese Tests verwenden keine echten Server.
SMB-Kopiertest: `pwsh -NoProfile -File ./NDTrack/tests/Test-SmbCopy.ps1` (simulierte Freigaben, keine Serverzugriffe).
## Version 1.0.3: ursprüngliche Task-Erstellung wiederhergestellt
Option 2 verwendet wieder /Create /S /TN /TR /SC Once /ST /RU /RP /RL HIGHEST /F wie das Original. Taskname NDTRACK, dynamischer Zielpfad und Exitcode-Prüfung bleiben erhalten. Benutzerkonto und Kennwort werden wieder abgefragt. Der Start erfolgt nach fünf Minuten; es gibt keinen zusätzlichen Sofortstart. Die Zeit wird auf dem Verwaltungsrechner berechnet und auf dem Zielserver als lokale Uhrzeit verwendet; gleiche Zeitzone und synchronisierte Uhren werden vorausgesetzt. Bei Überschreiten der Tagesgrenze wird vor Erstellung abgebrochen; nach Mitternacht erneut ausführen.
Kein XML und kein SYSTEM-Konto. Wie im Original wird kein Arbeitsverzeichnis in der Taskdefinition gesetzt. Die CMD muss selbst in ihren Ordner wechseln oder absolute Pfade verwenden. Ein vorhandener Task wird mit /F überschrieben; eine zusätzliche Remote-Zustandsabfrage ist nicht mehr vorgeschaltet. Option 2 daher nicht während eines laufenden Scans erneut ausführen.
Die CMD wird vorab über SMB auf Vorhandensein geprüft. Das Kennwort wird wie im Original als /RP-Argument übergeben. RPC-Taskverwaltung und das verwendete Task-Konto benötigen weiterhin die passenden Rechte. Die Rückkehr zum Originalaufruf ist keine bestätigte Behebung des Anmeldesitzungsfehlers; hierfür ist der Test auf deinen Windows-Servern erforderlich.
41 Ablauf-/Fehlerprüfungen und vier Task-Szenarien bestanden. Option 1 und PreScript unverändert.
+178
View File
@@ -0,0 +1,178 @@
--- Original/NDTrack.ps1
+++ Angepasst/NDTrack.ps1
@@ -1,14 +1,17 @@
# =========================
# Konfigurationsparameter
# =========================
-$global:SourcePath = "$env:USERPROFILE\Documents\Windows" # Pfad zur Quelldatei die verteilt werden soll
+$DocumentsPath = [Environment]::GetFolderPath('MyDocuments')
+$global:SourcePath = Join-Path $DocumentsPath 'Windows'
$global:DestinationPath = "C:\ndtrack" # Zielpfad auf den Remote Servern
$global:DestinationPath_RDS = "\RDSFIXV001\workfolders$\$env:USERPROFILE\Documents\windows"
$global:TaskName = "NDTrackTask"
#$global:TestServers = "GARRDSV003","GARRDSV002"
-$global:Dest_folder = "\\$f_server\c$\ndtrack"
-$global:logfile= "$env:USERPROFILES\Documents\"
-$global:Ergebnisordner= "$env:USERPROFILES\Documents\Ergebnisse"
+$global:logfile = Join-Path $DocumentsPath 'NDTrack-Logs'
+$global:Ergebnisordner = Join-Path $DocumentsPath 'Ergebnisse'
+
+New-Item -Path $logfile, $Ergebnisordner -ItemType Directory `
+ -Force -ErrorAction Stop | Out-Null
Import-Module RemoteDesktop
@@ -31,7 +34,8 @@
Write-Host "Option 7: NDTRACK von Systemen entfernen. (Linux|Textdatei)"
Write-Host "Option 8: RDS Server mittels NDTRACK scannen"
Write-Host "==============================================================================="
- $f_Choice = Read-Host -Prompt "Auswahl Variante (1-8)"
+ Write-Host "Option 0: Beenden"
+ $f_Choice = Read-Host -Prompt "Auswahl Variante (0-8)"
Write-Host
return $f_Choice
@@ -81,22 +85,22 @@
try{
# Zielordner prüfen
- Invoke-Command -ComputerName $f_Server -ScriptBlock {
- param($Dest_folder) # Anpassung an wirklichen Ordner
-
- #$a = !(Test-Path "\\$f_Server\c$") # TRUE, ohne ! immer false $f_Server anstatt $DestinationPath, asonsten keine valide Abfrage
- #write-host $a # Ausgabe zur kontrolle
-
- if ((Test-Path "\\$f_Server\c$")){
- New-Item -Path $DestinationPath -ItemType Directory #-Force #unbedingtes Schreiben ausgeschaltet
- }
- } -ArgumentList $DestinationPath
-
- #Datei auf Remote Server kopieren
- Copy-Item -Path "$SourcePath\*" -Destination "\\$f_Server\c$\ndtrack" -Recurse -Force # Schleife für das Abfange der Meldungen
+ $RemoteFolder = "\\$f_Server\c$\ndtrack"
+
+ if (-not (Test-Path -LiteralPath "$SourcePath\RunNdTrackWindows_Local.cmd" `
+ -PathType Leaf -ErrorAction Stop)) {
+ throw "Startdatei fehlt in $SourcePath."
+ }
+
+ New-Item -Path $RemoteFolder -ItemType Directory `
+ -Force -ErrorAction Stop | Out-Null
+
+ Copy-Item -Path "$SourcePath\*" -Destination $RemoteFolder `
+ -Recurse -Force -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
+ Write-Output $f_Server
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red
write-host $Error}
@@ -112,7 +116,34 @@
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
- schtasks.exe /Create /S $f_Server /TN $TaskName /TR "$DestinationPath\RunNdTrackWindows_Local.cmd" /SC "Once" /ST (Get-Date).AddMinutes(5).ToShortTimeString() /RU $User /RP $Password /RL "HIGHEST" /F
+ Invoke-Command -ComputerName $f_Server -ScriptBlock {
+ param($DestinationPath, $TaskName, [pscredential]$Credential)
+
+ $ErrorActionPreference = 'Stop'
+ $CmdPath = Join-Path $DestinationPath 'RunNdTrackWindows_Local.cmd'
+
+ if (-not (Test-Path -LiteralPath $CmdPath -PathType Leaf)) {
+ throw "Startdatei fehlt: $CmdPath"
+ }
+
+ $Action = New-ScheduledTaskAction `
+ -Execute "$env:SystemRoot\System32\cmd.exe" `
+ -Argument ('/d /s /c ""{0}""' -f $CmdPath) `
+ -WorkingDirectory $DestinationPath
+
+ $Trigger = New-ScheduledTaskTrigger `
+ -Once -At (Get-Date).AddMinutes(5)
+
+ $Settings = New-ScheduledTaskSettingsSet -StartWhenAvailable
+
+ Register-ScheduledTask -TaskName $TaskName `
+ -Action $Action -Trigger $Trigger -Settings $Settings `
+ -User $Credential.UserName `
+ -Password $Credential.GetNetworkCredential().Password `
+ -RunLevel Highest -Force | Out-Null
+
+ } -ArgumentList $DestinationPath, $TaskName, $ServiceAccount `
+ -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
@@ -213,18 +244,28 @@
try{
# Zielordner prüfen
- Invoke-Command -ComputerName $f_Server -ScriptBlock {
- param($Dest_folder) #Dest_folder=\\$f_server\c$\ndtrack
-
- if (Test-Path $Dest_folder) {
- Write-Host "Es wurde kein Inventory Ordner gefunden." -ForegroundColor Red
-
- }
- } -ArgumentList $Dest_folder
-
- # Datei vom Remote Server kopieren
- #Copy-Item -Path "\\$f_Server\c$\ndtrack\inventory\*" -Destination "$SourcePath\Result" -Recurse -Force
- Copy-Item -Path "\\$f_Server\c$\ndtrack\inventory\*" -Destination "c:\\users\qsadmin03\Documents\Ergebnisse" -Recurse -Force -PassThru #| Out-File -FilePath "$Source_Path\Result.txt" -Append
+ $InventoryPath = "\\$f_Server\c$\ndtrack\inventory"
+ $TargetPath = Join-Path $Ergebnisordner $f_Server
+
+ if (-not (Test-Path -LiteralPath $InventoryPath `
+ -PathType Container -ErrorAction Stop)) {
+ Write-Warning "${f_Server}: Kein Inventory-Ordner gefunden."
+ continue
+ }
+
+ $Files = @(Get-ChildItem -LiteralPath $InventoryPath `
+ -File -Recurse -ErrorAction Stop)
+
+ if ($Files.Count -eq 0) {
+ Write-Warning "${f_Server}: Keine Inventardateien vorhanden."
+ continue
+ }
+
+ New-Item -Path $TargetPath -ItemType Directory `
+ -Force -ErrorAction Stop | Out-Null
+
+ Copy-Item -Path "$InventoryPath\*" -Destination $TargetPath `
+ -Recurse -Force -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server Ergebnis geholt." -ForegroundColor Green
@@ -404,13 +445,14 @@
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
$ServiceAccount = Get-Credential -Message "User für Scheduled Task eingeben"
- $User = $ServiceAccount.UserName
- $Password = $ServiceAccount.GetNetworkCredential().Password
$AllServers = GetADServer
#$AllServers = $TestServers
- CopyFile $AllServers
- CreateScheduledTask $AllServers
+ $CopiedServers = @(CopyFile $AllServers)
+
+ if ($CopiedServers.Count -gt 0) {
+ CreateScheduledTask $CopiedServers
+ }
Stop-Transcript
} # Windows|AD Scheduled Task
@@ -470,9 +512,11 @@
Stop-Transcript
} # RDS|Textdatei löschen
+ 0 { }
+
default {
Write-Host "Das war wohl nix... Bitte versuche es erneut!" -ForegroundColor Red
Start-Sleep 2
}
}
-} while ($Choice -notin (1,2,3,4,5,6,7))+} while ($Choice -ne '0')
+464
View File
@@ -0,0 +1,464 @@
#Requires -Version 5.1
# Skriptversion: 1.0.3
# Versionsstand: 2026-10-15
<#
Korrigierte Kopie auf Basis des Originalskripts, mit denselben acht Optionen.
Windows-Verwaltungsrechner erforderlich. Die CMD-/SH-Dateien werden separat geliefert.
-LibraryOnly laedt nur Funktionen fuer isolierte Tests; fuehrt keine Aktionen aus.
#>
[CmdletBinding()]
param([switch]$LibraryOnly)
function Initialize-Configuration {
# Ablage auf dem ausfuehrenden Windows-Verwaltungsrechner:
# C:\SCAN\SCRIPT\NDTrack-Geprueft.ps1
$script:ScriptFolder = 'C:\SCAN\SCRIPT'
$script:SourcePath = 'C:\SCAN\NDTRACK'
$script:LinuxSourcePath = 'C:\SCAN\NDTRACK'
$script:DestinationPath = '' # Leer = Systemlaufwerk automatisch per WMI/DCOM ermitteln
$script:ServerDestinationPaths = @{} # Optional: @{ 'sql01.firma.example' = 'D:\ndtrack' }
$script:TaskName = 'NDTRACK'
$script:WindowsLauncher = 'RunNdTrackWindows_Local.cmd'
$script:LinuxLauncher = 'RunNdTrackLinuxUnix_Local.sh'
$script:Ergebnisordner = 'C:\SCAN\RESULTS'
$script:LogFolder = 'C:\SCAN\SCRIPT\Logs'
$script:TargetDomain = '' # Leer = DNS-Domaene des angemeldeten Benutzers
$script:DomainController = '' # Optional: FQDN eines DCs der Zieldomaene
$script:TestServers = @() # Zum Test z.B. @('GARRDSV003'); leer = AD/RDS
$script:RDSConnectionBroker = '' # Leer: wird bei Option 8 abgefragt
# Option 8 verwendet einen VOLLSTAENDIGEN, auf den RDS-Servern erreichbaren CMD-Pfad.
# Bei UNC-Pfaden muss der Remote-Ausfuehrungskontext Zugriff auf die Freigabe haben.
$script:RDSLauncherPath = '' # Kein Freigabepfad wird geraten.
}
function ShowMenu {
Write-Host @'
NDTRACK - Version 1.0.3 (Stand: 2026-10-15)
1: Windows - NDTrack-Dateien auf Server kopieren
2: Windows - Task NDTRACK mit Benutzerkonto erstellen (Start in 5 Minuten)
3: Windows - Scan-Dateien von Servern holen
4: Linux - NDTrack-Dateien auf Server kopieren
5: Linux - Scan per SSH starten
6: Linux - Scan-Dateien von Servern holen
7: Windows - aufraeumen (Task und NDTrack entfernen)
8: Linux - aufraeumen (NDTrack entfernen)
0: Beenden
'@
Read-Host 'Auswahl (0-8)'
}
function Assert-ServerName {
param([string]$Name)
if ($Name -notmatch '^[A-Za-z0-9][A-Za-z0-9.-]*$') {
throw "Ungueltiger Servername: $Name (DNS-Name oder IPv4 verwenden)."
}
}
function Get-DirectoryEndpoint {
# Keine kundenspezifischen Domain-DNs oder Servernamen.
if ($script:DomainController) {
Assert-ServerName $script:DomainController
return $script:DomainController
}
if ($script:TargetDomain) {
Assert-ServerName $script:TargetDomain
return $script:TargetDomain
}
if ($env:USERDNSDOMAIN) {
Assert-ServerName $env:USERDNSDOMAIN
return $env:USERDNSDOMAIN
}
throw 'Keine Benutzerdomaene ermittelbar. TargetDomain oder DomainController konfigurieren oder TestServers mit expliziten Zielservern fuellen.'
}
function GetADServer {
if ($script:TestServers.Count) {
foreach ($server in $script:TestServers) { Assert-ServerName $server }
return $script:TestServers | Sort-Object -Unique
}
$endpoint = Get-DirectoryEndpoint
$root = $null; $entry = $null; $searcher = $null; $results = $null
try {
$root = New-Object System.DirectoryServices.DirectoryEntry("LDAP://$endpoint/RootDSE")
$namingContext = [string]$root.Properties['defaultNamingContext'].Value
$dc = [string]$root.Properties['dnsHostName'].Value
if (-not $namingContext -or -not $dc) { throw 'RootDSE liefert keine AD-Domaene bzw. keinen DC.' }
Assert-ServerName $dc
# Optionalen DC auf Zugehoerigkeit zur expliziten Zieldomaene pruefen.
if ($script:TargetDomain) {
Assert-ServerName $script:TargetDomain
$expected = ($script:TargetDomain.TrimEnd('.').Split('.') | ForEach-Object { 'DC=' + $_ }) -join ','
if ($namingContext -ine $expected) { throw "DC gehoert zu $namingContext, erwartet wurde $expected." }
}
Write-Host "AD-AUSWAHL: $namingContext ueber $dc (aktuelles Windows-Konto)."
$entry = New-Object System.DirectoryServices.DirectoryEntry("LDAP://$dc/$namingContext")
$searcher = New-Object System.DirectoryServices.DirectorySearcher($entry)
$searcher.Filter = '(&(objectCategory=computer)(operatingSystem=*Server*)(!(userAccountControl:1.2.840.113556.1.4.803:=2)))'
$searcher.PageSize = 1000
[void]$searcher.PropertiesToLoad.Add('dnshostname')
[void]$searcher.PropertiesToLoad.Add('name')
$results = $searcher.FindAll()
$servers = @($results | ForEach-Object {
if ($_.Properties['dnshostname'].Count) {
$name = [string]$_.Properties['dnshostname'][0]
Assert-ServerName $name
$name
} else {
Write-Warning "AD-Computer $($_.Properties['name'][0]) ohne DNS-Hostnamen wird uebersprungen."
}
} | Sort-Object -Unique)
if (-not $servers.Count) { throw 'Keine aktivierten Windows-Server mit DNS-Hostnamen gefunden.' }
$servers
}
catch { throw "AD-Abfrage fuer '$endpoint' fehlgeschlagen: $($_.Exception.Message)" }
finally {
if ($null -ne $results) { $results.Dispose() }
if ($null -ne $searcher) { $searcher.Dispose() }
if ($null -ne $entry) { $entry.Dispose() }
if ($null -ne $root) { $root.Dispose() }
}
}
function GetRDSServer {
if ($script:TestServers.Count) { return $script:TestServers }
Import-Module RemoteDesktop -ErrorAction Stop
if (-not $script:RDSConnectionBroker) { $script:RDSConnectionBroker = Read-Host 'RDS Connection Broker (FQDN)' }
Assert-ServerName $script:RDSConnectionBroker
Get-RDServer -ConnectionBroker $script:RDSConnectionBroker -Role 'RDS-RD-SERVER' -ErrorAction Stop |
Select-Object -ExpandProperty Server -Unique
}
function GetLinuxServer {
$path = Read-Host 'Vollstaendiger Pfad zur Linux-Serverliste'
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) { throw "Serverliste nicht gefunden: $path" }
$names = @(Get-Content -LiteralPath $path -ErrorAction Stop | ForEach-Object { $_.Trim() } |
Where-Object { $_ -and -not $_.StartsWith('#') } | Sort-Object -Unique)
foreach ($name in $names) { Assert-ServerName $name }
$names
}
function Resolve-WindowsFolder {
param([string]$Server)
Assert-ServerName $Server
$folder = $script:DestinationPath
$overrides = Get-Variable -Name ServerDestinationPaths -Scope Script -ErrorAction SilentlyContinue
if ($overrides -and $overrides.Value.ContainsKey($Server)) { $folder = $overrides.Value[$Server] }
if (-not $folder) {
$cimSession = $null
try {
$options = New-CimSessionOption -Protocol Dcom -ErrorAction Stop
$cimSession = New-CimSession -ComputerName $Server -SessionOption $options -ErrorAction Stop
$os = Get-CimInstance -CimSession $cimSession -ClassName Win32_OperatingSystem -Property SystemDrive -ErrorAction Stop
$drive = [string]$os.SystemDrive
if ($drive -notmatch '^[A-Za-z]:$') { throw 'Kein gueltiges Systemlaufwerk vom Zielserver erhalten.' }
$folder = $drive + '\ndtrack'
} catch {
throw "Systemlaufwerk von '$Server' konnte per WMI/DCOM nicht ermittelt werden: $($_.Exception.Message)"
} finally {
if ($null -ne $cimSession) { Remove-CimSession -CimSession $cimSession -ErrorAction SilentlyContinue }
}
}
if ($folder -notmatch '^[A-Za-z]:\\[^"\r\n]+$' -or $folder -match '(?:^|\\)\.\.?(?:\\|$)') { throw 'Ungueltiger lokaler NDTrack-Zielpfad.' }
$folder.TrimEnd('\')
}
function Get-WindowsSharePath {
param([string]$Server)
$folder = Resolve-WindowsFolder $Server
'\\{0}\{1}$\{2}' -f $Server,$folder.Substring(0,1),$folder.Substring(3)
}
function CheckDirectory {
$paths = @($script:ScriptFolder,$script:SourcePath,$script:LinuxSourcePath,
$script:Ergebnisordner,$script:LogFolder) | Select-Object -Unique
foreach ($path in $paths) {
if (Test-Path -LiteralPath $path -ErrorAction Stop) {
if (-not (Test-Path -LiteralPath $path -PathType Container -ErrorAction Stop)) {
throw "Pfad ist eine Datei statt eines Ordners: $path"
}
Write-Host "ORDNER VORHANDEN: $path"
} else {
New-Item -Path $path -ItemType Directory -Force -ErrorAction Stop | Out-Null
Write-Host "ORDNER ANGELEGT: $path"
}
}
}
function Test-SourceFiles {
param([string]$Path,[string]$Launcher)
if (-not (Test-Path -LiteralPath $Path -PathType Container -ErrorAction Stop)) {
throw "Quellordner fehlt: $Path"
}
$files = @(Get-ChildItem -LiteralPath $Path -File -Recurse -Force -ErrorAction Stop)
if ($files.Count -eq 0) {
throw "Keine Dateien in $Path gefunden. Bitte das vollstaendige NDTrack-Paket dort ablegen und das Skript erneut starten. Leere Unterordner reichen nicht aus."
}
if ($Launcher) {
$launcherPath = Join-Path $Path $Launcher
if (-not (Test-Path -LiteralPath $launcherPath -PathType Leaf -ErrorAction Stop)) {
throw "Benoetigte Startdatei fehlt: $launcherPath"
}
if ((Get-Item -LiteralPath $launcherPath -ErrorAction Stop).Length -eq 0) {
throw "Startdatei ist leer: $launcherPath"
}
}
Write-Host "QUELLE GEPRUEFT: $Path - $($files.Count) Datei(en) vorhanden."
}
function CopyFile {
param([string[]]$Servers)
Test-SourceFiles -Path $script:SourcePath -Launcher $script:WindowsLauncher
foreach ($server in $Servers) {
try {
$folder = Resolve-WindowsFolder $server
$remote = '\\{0}\{1}$\{2}' -f $server,$folder.Substring(0,1),$folder.Substring(3)
$share = '\\{0}\{1}$' -f $server,$folder.Substring(0,1)
if (-not (Test-Path -LiteralPath $share -PathType Container -ErrorAction Stop)) {
throw "Freigabe nicht erreichbar: $share. Laufwerk, Freigabe und Berechtigungen pruefen."
}
if (Test-Path -LiteralPath ($remote + '\.ndtrack-running') -ErrorAction Stop) {
throw 'Scan-Sperre vorhanden; laufenden Scan bzw. verwaiste Sperre pruefen.'
}
New-Item -Path $remote -ItemType Directory -Force -ErrorAction Stop | Out-Null
Get-ChildItem -LiteralPath $script:SourcePath -Force -ErrorAction Stop |
Where-Object { $_.Name -notin @('inventory','Result','Ergebnisse','.ndtrack-running') } |
Copy-Item -Destination $remote -Recurse -Force -ErrorAction Stop
Write-Host "KOPIERT: $server -> $remote"
$server
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function CreateScheduledTask {
param([string[]]$Servers,[pscredential]$Credential)
if ($null -eq $Credential) { throw 'Kein Task-Konto angegeben.' }
foreach ($server in $Servers) {
$stage = 'Zielpfad ermitteln'
try {
$folder = Resolve-WindowsFolder $server
$share = '\\{0}\{1}$\{2}' -f $server,$folder.Substring(0,1),$folder.Substring(3)
$stage = 'CMD ueber SMB pruefen'
if (-not (Test-Path -LiteralPath ($share + '\' + $script:WindowsLauncher) -PathType Leaf -ErrorAction Stop)) { throw 'CMD fehlt; zuerst Option 1 ausfuehren.' }
$stage = 'Startzeit berechnen'
$now = Get-Date
$start = $now.AddMinutes(5)
if ($start.Date -ne $now.Date) { throw 'Startzeit liegt am Folgetag. Option 2 nach Mitternacht erneut ausfuehren.' }
$stage = 'Task mit urspruenglichem schtasks-Aufruf erstellen'
# Originalablauf: Benutzerkonto, einmaliger Start nach fuenf Minuten.
# Kein XML, kein SYSTEM, kein WinRM und kein zusaetzlicher /Run-Aufruf.
Invoke-NativeChecked 'schtasks.exe' @(
'/Create','/S',$server,'/TN',$script:TaskName,
'/TR',($folder + '\' + $script:WindowsLauncher),
'/SC','Once','/ST',$start.ToString('HH:mm'),
'/RU',$Credential.UserName,'/RP',$Credential.GetNetworkCredential().Password,
'/RL','HIGHEST','/F'
)
Write-Host "GEPLANT: $server - Task $script:TaskName fuer $($start.ToString('HH:mm')) erstellt. Scan-Abschluss noch nicht bestaetigt."
} catch { Write-Warning "${server}: $stage fehlgeschlagen: $($_.Exception.Message)" }
}
}
function Invoke-WindowsScan {
param([string[]]$Servers,[string]$LauncherPath)
foreach ($server in $Servers) {
try {
Assert-ServerName $server
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
param($path)
$ErrorActionPreference = 'Stop'
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) { throw "CMD nicht erreichbar: $path" }
$folder = Split-Path -Parent $path
$lock = Join-Path $folder '.ndtrack-running'
New-Item -Path $lock -ItemType Directory -ErrorAction Stop | Out-Null
try {
$process = Start-Process -FilePath "$env:SystemRoot\System32\cmd.exe" -ArgumentList ('/d /s /c ""{0}""' -f $path) -WorkingDirectory $folder -Wait -PassThru -NoNewWindow -ErrorAction Stop
if ($process.ExitCode -ne 0) { throw "CMD-Exitcode: $($process.ExitCode)" }
} finally { Remove-Item -LiteralPath $lock -Force -ErrorAction Stop }
} -ArgumentList $LauncherPath
Write-Host "BEENDET: $server - CMD-Exitcode 0."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function RunNDTRACKRemotely {
param([string[]]$Servers)
foreach ($server in $Servers) {
try {
$folder = Resolve-WindowsFolder $server
Invoke-WindowsScan @($server) ($folder + '\' + $script:WindowsLauncher)
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function Scan_RDS_SINA {
param([string[]]$Servers)
if (-not $script:RDSLauncherPath) { $script:RDSLauncherPath = Read-Host 'Vollstaendiger CMD-Pfad auf den RDS-Servern (lokal oder UNC)' }
if ($script:RDSLauncherPath -notmatch '^(?:[A-Za-z]:\\|\\\\).+\.cmd$' -or $script:RDSLauncherPath.Contains('"')) { throw 'Gueltigen absoluten RDS-CMD-Pfad konfigurieren.' }
Invoke-WindowsScan $Servers $script:RDSLauncherPath
}
function GetInventoryFiles {
param([string[]]$Servers)
$batch = Join-Path $script:Ergebnisordner ('Windows-' + [guid]::NewGuid().ToString('N'))
foreach ($server in $Servers) {
$session = $null
try {
$remote = Resolve-WindowsFolder $server
$session = New-PSSession -ComputerName $server -ErrorAction Stop
Invoke-Command -Session $session -ErrorAction Stop -ScriptBlock {
param($folder,$name)
$ErrorActionPreference = 'Stop'
if (Test-Path -LiteralPath (Join-Path $folder '.ndtrack-running')) { throw 'Scan laeuft oder Sperre ist verwaist.' }
$task = Get-ScheduledTask | Where-Object { $_.TaskName -eq $name -and $_.TaskPath -eq '\' }
if ($task) {
$info = Get-ScheduledTaskInfo -TaskName $name -TaskPath '\'
if ($task.State -in @('Running','Queued') -or $info.LastTaskResult -ne 0 -or $info.NextRunTime -gt (Get-Date)) { throw 'Task noch ausstehend/aktiv oder letzter Lauf fehlerhaft.' }
}
$inventory = Join-Path $folder 'inventory'
$files = @(Get-ChildItem -LiteralPath $inventory -File -Recurse)
if (-not $files.Count) { throw 'Keine Inventardateien vorhanden.' }
} -ArgumentList $remote,$script:TaskName
$inventory = $remote + '\inventory'
$target = Join-Path $batch $server
New-Item -Path $target -ItemType Directory -Force -ErrorAction Stop | Out-Null
Copy-Item -Path "$inventory\*" -FromSession $session -Destination $target -Recurse -Force -ErrorAction Stop
Write-Host "EINGESAMMELT: $server -> $target (vorhandene Dateien, Alter nicht bewertet)."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
finally { if ($null -ne $session) { Remove-PSSession -Session $session } }
}
}
function DeleteScheduledTask {
param([string[]]$Servers)
foreach ($server in $Servers) {
try {
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
param($name)
$ErrorActionPreference = 'Stop'
$task = Get-ScheduledTask | Where-Object { $_.TaskName -eq $name -and $_.TaskPath -eq '\' }
if ($task) {
Disable-ScheduledTask -TaskName $name -TaskPath '\' | Out-Null
Stop-ScheduledTask -TaskName $name -TaskPath '\'
$deadline = (Get-Date).AddSeconds(30)
do {
$state = (Get-ScheduledTask -TaskName $name -TaskPath '\').State
if ($state -notin @('Running','Queued')) { break }
Start-Sleep -Milliseconds 500
} while ((Get-Date) -lt $deadline)
if ($state -in @('Running','Queued')) { throw 'Task konnte nicht gestoppt werden.' }
Unregister-ScheduledTask -TaskName $name -TaskPath '\' -Confirm:$false
}
} -ArgumentList $script:TaskName
$server
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function DeleteFile {
param([string[]]$Servers)
foreach ($server in $Servers) {
try {
$folder = Resolve-WindowsFolder $server
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
param($folder)
$ErrorActionPreference = 'Stop'
# Nur den dedizierten NDTrack-Ordner entfernen.
if ($folder.TrimEnd('\') -notmatch '^[A-Za-z]:\\.+$' -or $folder -match '(?:^|\\)\.\.?(?:\\|$)' -or (Split-Path $folder.TrimEnd('\') -Leaf) -ne 'ndtrack') { throw 'Loeschen nur fuer einen dedizierten ndtrack-Ordner erlaubt.' }
if (Test-Path -LiteralPath (Join-Path $folder '.ndtrack-running')) { throw 'Direkter Scan aktiv oder Sperre verwaist.' }
$processes = @(Get-CimInstance Win32_Process -Filter "Name = 'ndtrack.exe'")
foreach ($process in $processes) {
if (-not $process.ExecutablePath -or $process.ExecutablePath.StartsWith($folder.TrimEnd('\')+'\',[StringComparison]::OrdinalIgnoreCase)) { throw 'NDTrack-Prozess noch aktiv; keine Dateien geloescht.' }
}
if (Test-Path -LiteralPath $folder) { Remove-Item -LiteralPath $folder -Recurse -Force }
} -ArgumentList $folder
Write-Host "ENTFERNT: $server - NDTrack-Ordner."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
# Native Programme: Exitcode immer direkt pruefen.
function Invoke-NativeChecked {
param([string]$Program,[string[]]$Arguments)
& $Program @Arguments | Out-Host
if ($LASTEXITCODE -ne 0) { throw "$Program fehlgeschlagen (Exitcode $LASTEXITCODE)." }
}
function Get-LinuxUser {
$userName = Read-Host 'Linux-SSH-Benutzer (z.B. scanuser; kein Windows-Domaenenformat)'
if ($userName -notmatch '^[a-zA-Z_][a-zA-Z0-9_.-]*[$]?$') { throw 'Ungueltiger Linux-Benutzername.' }
$userName
}
function Invoke-LinuxCommand {
param([string]$Server,[string]$User,[string]$Command)
Assert-ServerName $Server
Invoke-NativeChecked 'ssh' @('-o','ConnectTimeout=15','-l',$User,$Server,$Command)
}
function CopyFileLinux {
param([string[]]$Servers,[string]$User)
Test-SourceFiles -Path $script:LinuxSourcePath -Launcher $script:LinuxLauncher
foreach ($server in $Servers) {
try {
Invoke-LinuxCommand $server $User 'test ! -d "$HOME/ndtrack/.ndtrack-running" && mkdir -p "$HOME/ndtrack"'
$items = @(Get-ChildItem -LiteralPath $script:LinuxSourcePath -Force -ErrorAction Stop | Where-Object { $_.Name -notin @('inventory','.ndtrack-running') })
foreach ($item in $items) { Invoke-NativeChecked 'scp' @('-r','-o','ConnectTimeout=15',$item.FullName,"${User}@${server}:ndtrack/") }
Write-Host "KOPIERT: $server"
$server
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function RunNDTRACKRemotelyLinux {
param([string[]]$Servers,[string]$User)
foreach ($server in $Servers) {
try {
# Interpreter aus der Shebang verwenden; Startdatei muss synchron laufen.
$command = 'cd "$HOME/ndtrack" && mkdir .ndtrack-running && { trap ''rmdir "$HOME/ndtrack/.ndtrack-running"'' EXIT; chmod u+x ./RunNdTrackLinuxUnix_Local.sh && ./RunNdTrackLinuxUnix_Local.sh; }'
Invoke-LinuxCommand $server $User $command
Write-Host "BEENDET: $server - SH-Exitcode 0."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function GetInventoryFilesLinux {
param([string[]]$Servers,[string]$User)
$batch = Join-Path $script:Ergebnisordner ('Linux-' + [guid]::NewGuid().ToString('N'))
foreach ($server in $Servers) {
try {
Invoke-LinuxCommand $server $User 'test ! -d "$HOME/ndtrack/.ndtrack-running" && test -d "$HOME/ndtrack/inventory" && test -n "$(find "$HOME/ndtrack/inventory" -type f -print -quit)"'
$target = Join-Path $batch $server
New-Item -Path $target -ItemType Directory -Force -ErrorAction Stop | Out-Null
Invoke-NativeChecked 'scp' @('-r','-o','ConnectTimeout=15',"${User}@${server}:ndtrack/inventory",$target)
Write-Host "EINGESAMMELT: $server -> $target (vorhandene Dateien, Alter nicht bewertet)."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function DeleteFileLinux {
param([string[]]$Servers,[string]$User)
foreach ($server in $Servers) {
try {
# Bei fehlendem pgrep ebenfalls abbrechen statt einen laufenden Scan zu riskieren.
$command = 'test -n "$HOME" && test "$HOME" != / && test ! -d "$HOME/ndtrack/.ndtrack-running" && command -v pgrep >/dev/null && { pgrep -x ndtrack >/dev/null; rc=$?; test "$rc" -eq 1; } && rm -rf -- "$HOME/ndtrack"'
Invoke-LinuxCommand $server $User $command
Write-Host "ENTFERNT: $server - NDTrack-Ordner."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function Invoke-MenuOption {
param([string]$Choice)
switch ($Choice) {
'1' { CopyFile @(GetADServer) | Out-Null }
'2' {
$credential = Get-Credential -Message 'Ausfuehrungskonto fuer Task NDTRACK (DOMAENE\Benutzer)'
if ($null -eq $credential) { throw 'Kontoabfrage abgebrochen.' }
CreateScheduledTask @(GetADServer) $credential
}
'3' { GetInventoryFiles @(GetADServer) }
'4' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; CopyFileLinux $servers $userName | Out-Null }
'5' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; RunNDTRACKRemotelyLinux $servers $userName }
'6' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; GetInventoryFilesLinux $servers $userName }
'7' { $servers = @(GetADServer); $cleared = @(DeleteScheduledTask $servers); if ($cleared.Count) { DeleteFile $cleared } }
'8' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; DeleteFileLinux $servers $userName }
'0' { return }
default { throw 'Bitte eine Option zwischen 0 und 8 waehlen.' }
}
}
if (-not $LibraryOnly) {
if ($env:OS -ne 'Windows_NT') { throw 'Auf einem Windows-Verwaltungsrechner ausfuehren; Mac nur zum Bearbeiten/Testen.' }
Initialize-Configuration
CheckDirectory
Test-SourceFiles -Path $script:SourcePath
do {
$choice = ShowMenu
if ($choice -eq '0') { break }
$transcriptStarted = $false
try {
$log = Join-Path $script:LogFolder ('NDTrack-{0}.log' -f (Get-Date -Format 'yyyyMMdd-HHmmss-fff'))
Start-Transcript -Path $log -ErrorAction Stop | Out-Null
$transcriptStarted = $true
Invoke-MenuOption $choice
} catch { Write-Warning $_.Exception.Message }
finally { if ($transcriptStarted) { Stop-Transcript | Out-Null } }
} while ($true)
}
+522
View File
@@ -0,0 +1,522 @@
# =========================
# Konfigurationsparameter
# =========================
$DocumentsPath = [Environment]::GetFolderPath('MyDocuments')
$global:SourcePath = Join-Path $DocumentsPath 'Windows'
$global:DestinationPath = "C:\ndtrack" # Zielpfad auf den Remote Servern
$global:DestinationPath_RDS = "\RDSFIXV001\workfolders$\$env:USERPROFILE\Documents\windows"
$global:TaskName = "NDTrackTask"
#$global:TestServers = "GARRDSV003","GARRDSV002"
$global:logfile = Join-Path $DocumentsPath 'NDTrack-Logs'
$global:Ergebnisordner = Join-Path $DocumentsPath 'Ergebnisse'
New-Item -Path $logfile, $Ergebnisordner -ItemType Directory `
-Force -ErrorAction Stop | Out-Null
Import-Module RemoteDesktop
# =========================
# Funktionen
# =========================
function ShowMenu(){
param()
cls
Write-Host "================================================================================"
Write-Host "Dieses Script bietet verschiedene Optionen die Softwareinventur durchzuführen."
Write-Host
Write-Host "Option 1: Remote Ausführung von NDTRACK mittels Remoting. (Windows|AD)"
Write-Host "Option 2: Lokale Ausführung von NDTRACK mittels Scheduled Task. (Windows|AD)"
Write-Host "Option 3: Lokale Ausführung von NDTRACK mittels SSH. (Linux|Textdatei)"
Write-Host "Option 4: Inventory Dateien einsammeln. (Windows|AD)"
Write-Host "Option 5: Inventory Dateien einsammeln. (Linux|Textdatei)"
Write-Host "Option 6: NDTRACK und Scheduled Task von Systemen entfernen. (Windows|AD)"
Write-Host "Option 7: NDTRACK von Systemen entfernen. (Linux|Textdatei)"
Write-Host "Option 8: RDS Server mittels NDTRACK scannen"
Write-Host "==============================================================================="
Write-Host "Option 0: Beenden"
$f_Choice = Read-Host -Prompt "Auswahl Variante (0-8)"
Write-Host
return $f_Choice
}
function GetADServer(){
param()
Write-Host "Server aus dem Active Directory werden ausgelesen ..." -ForegroundColor Cyan
$f_DomainDN = ([ADSI]"").distinguishedName
$f_Searcher = New-Object adsisearcher
$f_Searcher.SearchRoot = "LDAP://$f_DomainDN" # Muss angepasst werden
$f_Searcher.Filter = "(&(objectClass=computer)(operatingSystem=*Server*))"
$f_Searcher.PageSize = 1000
$f_Servers = $f_Searcher.FindAll() | ForEach-Object {$_.Properties.name}
return $f_Servers
}
function GetRDSServer(){
param()
Write-Host "RDSServer aus dem Active Directory werden ausgelesen ..." -ForegroundColor Cyan
$f_DomainDN = ([ADSI]"").distinguishedName
$f_Searcher = New-Object adsisearcher
$f_Searcher.SearchRoot = "LDAP://$f_DomainDN" # Muss angepasst werden
$f_rds_Servers = Get-RDServer
return $f_rds_Servers
}
function CopyFile(){
param($f_AllServers)
Write-Host "Ordner werden angelegt und Dateien kopiert ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
#write-host $DestinationPath
if (-not (Test-Path "\\$f_server\c$")){
write-host "$f_server : c$ ist nicht verfügbar"
continue
}
try{
# Zielordner prüfen
$RemoteFolder = "\\$f_Server\c$\ndtrack"
if (-not (Test-Path -LiteralPath "$SourcePath\RunNdTrackWindows_Local.cmd" `
-PathType Leaf -ErrorAction Stop)) {
throw "Startdatei fehlt in $SourcePath."
}
New-Item -Path $RemoteFolder -ItemType Directory `
-Force -ErrorAction Stop | Out-Null
Copy-Item -Path "$SourcePath\*" -Destination $RemoteFolder `
-Recurse -Force -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
Write-Output $f_Server
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red
write-host $Error}
}
}
function CreateScheduledTask(){
param($f_AllServers)
Write-Host "Scheduled Tasks werden angelegt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($DestinationPath, $TaskName, [pscredential]$Credential)
$ErrorActionPreference = 'Stop'
$CmdPath = Join-Path $DestinationPath 'RunNdTrackWindows_Local.cmd'
if (-not (Test-Path -LiteralPath $CmdPath -PathType Leaf)) {
throw "Startdatei fehlt: $CmdPath"
}
$Action = New-ScheduledTaskAction `
-Execute "$env:SystemRoot\System32\cmd.exe" `
-Argument ('/d /s /c ""{0}""' -f $CmdPath) `
-WorkingDirectory $DestinationPath
$Trigger = New-ScheduledTaskTrigger `
-Once -At (Get-Date).AddMinutes(5)
$Settings = New-ScheduledTaskSettingsSet -StartWhenAvailable
Register-ScheduledTask -TaskName $TaskName `
-Action $Action -Trigger $Trigger -Settings $Settings `
-User $Credential.UserName `
-Password $Credential.GetNetworkCredential().Password `
-RunLevel Highest -Force | Out-Null
} -ArgumentList $DestinationPath, $TaskName, $ServiceAccount `
-ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen - $_" -ForegroundColor Red}
}
}
function DeleteFile(){
param($f_AllServers)
Write-Host "Dateien werden von den Servern gelöscht ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Lösche Datei von $f_Server ..." -ForegroundColor Cyan
try{
# Zielordner prüfen
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($DestinationPath)
if (Test-Path $DestinationPath){
Remove-Item -Path $DestinationPath -Recurse -Force
Write-Output "Datei gelöscht."
}
else{
Write-Output "Datei nicht gefunden."
}
} -ArgumentList $DestinationPath -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server entfernt." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server Entfernen fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function DeleteScheduledTask(){
param($f_AllServers)
Write-Host "Scheduled Tasks werden gelöscht ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($TaskName)
if (Get-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue){
Unregister-ScheduledTask -TaskName $TaskName -Confirm:$false
Write-Output "Scheduled Task entfernt."
}
else{
Write-Output "Scheduled Task nicht gefunden."
}
} -ArgumentList $TaskName -AsJob -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server gelöscht." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server Löschung gescheitert - $_" -ForegroundColor Red}
}
}
function RunNDTRACKRemotely(){
param($f_AllServers)
Write-Host "NDTRACK wird ausgeführt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($DestinationPath)
&"$DestinationPath\RunNdTrackWindows_Local.cmd"
} -ArgumentList $DestinationPath -AsJob -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen - $_" -ForegroundColor Red}
}
}
function GetInventoryFiles(){
param($f_AllServers)
Write-Host "Inventory Dateien werden eingesammelt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
if (-not (Test-Path "\\$f_server\c$")){
write-host "$f_server : c$ ist nicht verfügbar"
continue
}
try{
# Zielordner prüfen
$InventoryPath = "\\$f_Server\c$\ndtrack\inventory"
$TargetPath = Join-Path $Ergebnisordner $f_Server
if (-not (Test-Path -LiteralPath $InventoryPath `
-PathType Container -ErrorAction Stop)) {
Write-Warning "${f_Server}: Kein Inventory-Ordner gefunden."
continue
}
$Files = @(Get-ChildItem -LiteralPath $InventoryPath `
-File -Recurse -ErrorAction Stop)
if ($Files.Count -eq 0) {
Write-Warning "${f_Server}: Keine Inventardateien vorhanden."
continue
}
New-Item -Path $TargetPath -ItemType Directory `
-Force -ErrorAction Stop | Out-Null
Copy-Item -Path "$InventoryPath\*" -Destination $TargetPath `
-Recurse -Force -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server Ergebnis geholt." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function GetLinuxServer(){
param()
Do {
$f_FileLocation = Read-Host -Prompt "Bitte den vollständigen Pfad zur Textdatei eingeben"
} while (!(Test-Path $f_FileLocation))
Write-Host "Linux-Server aus Textdatei werden ausgelesen ..." -ForegroundColor Cyan
$f_Servers = Get-Content -Path $f_FileLocation
return $f_Servers
}
function CopyFileLinux(){
param($f_AllServers)
Write-Host "Ordner werden angelegt und Dateien kopiert ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
# Befehl erzeugen
$f_Command = "mkdir /home/$User/ndtrack"
# Ordner erstellen
ssh "$User@$f_Server" $f_Command
# Datei auf Remote Server kopieren
scp -r "$SourcePath\*" "$User@$f_Server`:/home/$User/ndtrack"
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function RunNDTRACKRemotelyLinux(){
param($f_AllServers)
Write-Host "NDTRACK wird ausgeführt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
# Befehl erzeugen
$f_Command = "/home/$User/ndtrack/RunNdTrackLinuxUnix_Local.sh"
# NDTrack ausführen
ssh "$User@$f_Server" $f_Command
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen - $_" -ForegroundColor Red}
}
}
function GetInventoryFilesLinux(){
param($f_AllServers)
Write-Host "Inventory Dateien werden eingesammelt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
# Nutzer einlesen
$f_User = Read-Host -Prompt "Nutzer in Form User@Domain eingeben"
# Datei vom Remote Server kopieren
scp "$f_User@$f_Server`:/home/$f_User/ndtrack/inventory/*" "$SourcePath\Result"
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function DeleteFileLinux(){
param($f_AllServers)
Write-Host "Dateien werden von den Servern gelöscht ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Lösche Datei von $f_Server ..." -ForegroundColor Cyan
try{
# Nutzer einlesen
$f_User = Read-Host -Prompt "Nutzer in Form User@Domain eingeben"
# Befehl erzeugen
$f_Command = "rm -r /home/$f_User/ndtrack"
# Ordner und Dateien löschen
ssh "$f_User@$f_Server" $f_Command
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function CheckDirectory() {
# test if folder exists
if (Test-Path -Path $Ergebnisordner) {
Write-Host "Ergebnis Ordner besteht bereits" -ForegroundColor yellow
} else {
"Verzeichnis existiert nicht. Wird erzeugt"
if (New-Item -ItemType Directory -Force -Path $Ergebnisordner) {
"Ergebniss Verzeichnis Erzeugt"
} else {
exit
}
}
}
function Scan_RDS_SINA () {
# special routine for KdoIT-Bws gehärtete SINA RDS Clients
param($f_AllServers)
Write-Host "NDTRACK wird ausgeführt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($DestinationPath_RDS)
&"$DestinationPath_RDS\RunNdTrackWindows_Local_RDSSINA.cmd"
} -ArgumentList $DestinationPath_RDS -AsJob -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen - $_" -ForegroundColor Red}
}
}
# =========================
# Hauptprogramm
# =========================
Do {
$Choice = ShowMenu
Switch ($Choice){
1 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
write-host $Ergebnisordner
CheckDirectory
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetADServer
#$AllServers = $TestServers
CopyFile $AllServers
RunNDTRACKRemotely $AllServers
Stop-Transcript
} # Windows|AD Remoting
2 {
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
$ServiceAccount = Get-Credential -Message "User für Scheduled Task eingeben"
$AllServers = GetADServer
#$AllServers = $TestServers
$CopiedServers = @(CopyFile $AllServers)
if ($CopiedServers.Count -gt 0) {
CreateScheduledTask $CopiedServers
}
Stop-Transcript
} # Windows|AD Scheduled Task
3 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetLinuxServer
# Nutzer einlesen
$User = Read-Host -Prompt "Nutzer in Form User@Domain eingeben"
CopyFileLinux $AllServers
RunNDTRACKRemotelyLinux $AllServers
Stop-Transcript
} # Linux|Textdatei SSH
4 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetADServer
#$AllServers = $TestServers
GetInventoryFiles $AllServers
Stop-Transcript
} # Windows|AD einsammeln
5 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetLinuxServer
GetInventoryFilesLinux $AllServers
Stop-Transcript
} # Linux|Textdatei einsammeln
6 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetADServer
#$AllServers = $TestServers
DeleteFile $AllServers
DeleteScheduledTask $AllServers
Stop-Transcript
} # Windows|AD löschen
7 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetLinuxServer
DeleteFileLinux $AllServers
Stop-Transcript
} # Linux|Textdatei löschen
8 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetRDSServer
DeleteFileRDS $AllServers
Stop-Transcript
} # RDS|Textdatei löschen
0 { }
default {
Write-Host "Das war wohl nix... Bitte versuche es erneut!" -ForegroundColor Red
Start-Sleep 2
}
}
} while ($Choice -ne '0')
+75
View File
@@ -0,0 +1,75 @@
#Requires -Version 5.1
# Skriptversion: 1.0.0
# Versionsstand: 2026-10-15
<#
Vorbereitung auf dem Windows-Verwaltungsrechner. Keine Serverzugriffe.
Beispiel: .\PreScript.ps1 -Platform Windows
Prueft nur vorhandene Ordner und Dateien. Bei Erfolg wird das Hauptskript gestartet.
Fehlende Ordner und Dateien muessen vorab bereitgestellt werden.
#>
[CmdletBinding()]
param(
[ValidateSet('Windows','Linux','Both')]
[string]$Platform = 'Windows',
[string]$BasePath = 'C:\SCAN'
)
$ErrorActionPreference = 'Stop'
try {
$scriptFolder = Join-Path $BasePath 'SCRIPT'
$sourceFolder = Join-Path $BasePath 'NDTRACK'
$resultFolder = Join-Path $BasePath 'RESULTS'
$logFolder = Join-Path $scriptFolder 'Logs'
foreach ($path in @($scriptFolder,$sourceFolder,$resultFolder,$logFolder)) {
if (Test-Path -LiteralPath $path) {
if (-not (Test-Path -LiteralPath $path -PathType Container)) {
throw "Pfad ist eine Datei statt eines Ordners: $path"
}
Write-Host "VORHANDEN: $path"
} else {
throw "Benoetigter Ordner fehlt: $path. Bitte vor dem Start bereitstellen."
}
}
$issues = [System.Collections.Generic.List[string]]::new()
$mainScript = Join-Path $scriptFolder 'NDTrack-Geprueft.ps1'
if (-not (Test-Path -LiteralPath $mainScript -PathType Leaf)) {
$issues.Add("Hauptskript fehlt: $mainScript. Bitte die erstellte Skriptdatei dorthin kopieren.")
} elseif ((Get-Item -LiteralPath $mainScript).Length -eq 0) {
$issues.Add("Hauptskript ist leer: $mainScript")
} else {
$tokens=$null; $parseErrors=$null
[void][System.Management.Automation.Language.Parser]::ParseFile($mainScript,[ref]$tokens,[ref]$parseErrors)
if ($parseErrors.Count) { $issues.Add("Hauptskript enthaelt PowerShell-Syntaxfehler: $($parseErrors -join '; ')") }
}
$files = @(Get-ChildItem -LiteralPath $sourceFolder -File -Recurse -Force)
if (-not $files.Count) {
$issues.Add("Keine Dateien in $sourceFolder. Bitte das vollstaendige NDTrack-Paket entpackt dort ablegen; leere Unterordner reichen nicht aus.")
} else {
Write-Host "DATEIEN: $($files.Count) in $sourceFolder (inklusive Unterordner)."
}
$launchers = @()
if ($Platform -in @('Windows','Both')) { $launchers += 'RunNdTrackWindows_Local.cmd' }
if ($Platform -in @('Linux','Both')) { $launchers += 'RunNdTrackLinuxUnix_Local.sh' }
foreach ($name in $launchers) {
$path = Join-Path $sourceFolder $name
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) {
$issues.Add("Startdatei fehlt direkt im Quellordner: $path")
} elseif ((Get-Item -LiteralPath $path).Length -eq 0) {
$issues.Add("Startdatei ist leer: $path")
} else { Write-Host "STARTDATEI VORHANDEN: $name" }
}
if ($issues.Count) {
foreach ($issue in $issues) { Write-Warning $issue }
Write-Host 'VORBEREITUNG UNVOLLSTAENDIG. Fehlende Dateien ergaenzen und PreScript erneut ausfuehren.' -ForegroundColor Yellow
exit 1
}
Write-Host 'VORBEREITUNG OK: Ordner und benoetigte Startdateien vorhanden; Hauptskript syntaktisch gueltig.' -ForegroundColor Green
Write-Host 'Paketvollstaendigkeit, CMD-/SH-Inhalt und Zielserver-Erreichbarkeit wurden nicht geprueft.'
Write-Host "Starte Hauptskript: $mainScript"
& $mainScript
exit 0
} catch {
Write-Warning "Vorbereitung fehlgeschlagen: $($_.Exception.Message)"
exit 1
}
+58
View File
@@ -0,0 +1,58 @@
# NDTrack: gezielte Änderungen und Git-Anleitung
## Dateien
- `NDTrack.ps1`: dein Originalskript mit ausschließlich den zuletzt besprochenen Änderungen.
- `Aenderungen.diff`: Vergleich mit dem eingefügten Original; ohne den UTF-8-BOM der Ausgabedatei dargestellt.
Die Änderungen betreffen Benutzerpfade, Erstellen der lokalen Ausgabeordner, Kopieren auf die Server, Task-Erstellung, Übergabe erfolgreich belieferter Server, Einsammeln je Server und Beenden über Option 0. Die übrigen Funktionen wurden nicht überarbeitet. Das Skript ist für Windows; auf dem Mac kannst du es bearbeiten und mit Git verwalten.
## Auf Windows verwenden
1. `NDTrack.ps1` auf deinen Windows-Verwaltungsrechner kopieren.
2. Die NDTrack-Dateien einschließlich `RunNdTrackWindows_Local.cmd` im Dokumente-Unterordner `Windows` des ausführenden Benutzers ablegen.
3. PowerShell unter einem Konto mit Zugriff auf die administrativen Freigaben der Zielserver und Berechtigung für PowerShell-Remoting starten.
4. Im Skriptverzeichnis ` .\NDTrack.ps1 ` ausführen.
5. Option 2 verteilt die Dateien und fragt das Konto für den geplanten Task ab. Der einmalige Task startet fünf Minuten nach seiner Erstellung auf dem jeweiligen Server.
6. Nach Abschluss des Scans Option 4 wählen. Die Dateien werden unter `Dokumente\Ergebnisse\SERVERNAME` des Benutzers gespeichert, unter dessen Konto PowerShell läuft. Bei „Als anderer Benutzer ausführen“ ist dies das andere Konto, nicht automatisch der am Desktop angemeldete Benutzer.
7. Option 0 beendet das Skript. Protokolle liegen unter `Dokumente\NDTrack-Logs`.
Ohne Anpassung der vorhandenen Serverauswahl werden Server aus dem AD verwendet. Für einen Test kannst du die vorhandenen Testserver-Zeilen aktivieren und die entsprechende AD-Auswahl in Option 2 und 4 auskommentieren; dies wurde in der gelieferten Datei nicht vorgenommen.
## Bekannte, unveränderte Punkte
- Option 4 kopiert vorhandene Dateien, ohne Task-Abschluss oder Aktualität zu prüfen.
- Die CMD-Datei war nicht enthalten. Ihre Funktionsweise und die Ausgabe nach `C:\ndtrack\inventory` sind daher nicht geprüft.
- Linux-, RDS- und Löschfunktionen behalten die zuvor besprochenen Fehler. Insbesondere verweist Option 8 weiterhin auf die nicht vorhandene Funktion `DeleteFileRDS`.
- Der vorhandene Import von `RemoteDesktop` ist unverändert. Fehlt das Modul, meldet PowerShell einen Importfehler.
- Die Task-Erstellung benötigt jetzt PowerShell-Remoting und das Modul `ScheduledTasks` auf den Zielservern. Das Task-Konto benötigt die nötigen Rechte für Scan und geplante Ausführung.
Die PowerShell-Syntax wurde auf dem Mac geprüft. Es wurden keine Server angesprochen und keine Tasks erstellt.
## Git im vorhandenen Arbeitsordner
Das Skript liegt unter `NDTrack/NDTrack.ps1` im bestehenden Repository. Kein `git init` erforderlich. Im Terminal:
```bash
cd '/Users/michaeltroebs/Documents/GIT/syno-scripts'
git status --short
git add NDTrack/NDTrack.ps1 NDTrack/README.md NDTrack/Aenderungen.diff
git diff --cached -- NDTrack/
git commit -m "NDTrack: Benutzerpfade und Windows-Verteilung korrigieren" -- NDTrack/
```
Der Commit-Befehl beschränkt sich auf den Ordner NDTrack. Andere vorhandene Änderungen bleiben außerhalb dieses Commits. Der erste Commit enthält den angepassten Stand; den Vergleich zum eingefügten Original findest du in `Aenderungen.diff`.
Spätere Änderungen vor dem Vormerken prüfen:
```bash
git diff -- NDTrack/NDTrack.ps1
```
Optional nach dem Commit auf den bereits eingerichteten Remote übertragen, sofern der aktuelle Branch einen Upstream hat:
```bash
git push
```
Codex hat die Dateien nur abgelegt: nichts vorgemerkt, committed oder hochgeladen.
+26
View File
@@ -0,0 +1,26 @@
$ErrorActionPreference='Stop'
. (Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1') -LibraryOnly
$saved=$env:USERDNSDOMAIN
function Assert { param($Condition) if(-not $Condition){throw 'Domaenenauswahl falsch'} }
try {
$script:TargetDomain=''; $script:DomainController=''
$env:USERDNSDOMAIN='first.example'
Assert ((Get-DirectoryEndpoint) -eq 'first.example')
$env:USERDNSDOMAIN='second.example'
Assert ((Get-DirectoryEndpoint) -eq 'second.example')
$script:TargetDomain='target.example'
Assert ((Get-DirectoryEndpoint) -eq 'target.example')
$script:DomainController='dc01.target.example'
Assert ((Get-DirectoryEndpoint) -eq 'dc01.target.example')
$script:DomainController=''; $script:TargetDomain=''; $env:USERDNSDOMAIN=''
$failed=$false
try { Get-DirectoryEndpoint } catch { $failed=$true }
Assert $failed
$script:TargetDomain='invalid/path'
$failed=$false
try { Get-DirectoryEndpoint } catch { $failed=$true }
Assert $failed
$script:TestServers=@('sql01.target.example','sql01.target.example')
Assert ((@(GetADServer)).Count -eq 1)
Write-Host '7 Domaenenauswahl-Pruefungen bestanden; keine echte AD-Verbindung.'
} finally { $env:USERDNSDOMAIN=$saved }
+102
View File
@@ -0,0 +1,102 @@
# Isolierte Tests: keine Serverzugriffe oder echten Loeschungen.
$ErrorActionPreference = 'Stop'
$path = Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1'
$t=$null; $e=$null
[void][System.Management.Automation.Language.Parser]::ParseFile($path,[ref]$t,[ref]$e)
if ($e.Count) { throw ($e | Out-String) }
. $path -LibraryOnly
$script:checks=0
function Assert { param($Condition,$Message) if(-not $Condition){throw $Message}; $script:checks++ }
function Invoke-Command { param($ComputerName,$ScriptBlock,[object[]]$ArgumentList,$ErrorAction) & $ScriptBlock @ArgumentList }
function Test-Path { $true }
function New-CimSessionOption { param($Protocol,$ErrorAction) if($Protocol -ne 'Dcom'){throw 'Falsches Protokoll'}; 'DCOM' }
function New-CimSession { param($ComputerName,$SessionOption,$ErrorAction) $ComputerName }
function Get-CimInstance { [pscustomobject]@{SystemDrive='E:'} }
function Remove-CimSession { }
$script:ServerDestinationPaths=@{}
$script:DestinationPath=''
Assert ((Resolve-WindowsFolder 'server01') -eq 'E:\ndtrack') 'Automatisches Systemlaufwerk falsch'
$script:ServerDestinationPaths=@{'server02'='E:\ndtrack'}
Assert ((Get-WindowsSharePath 'server02') -eq '\\server02\E$\ndtrack') 'Server-Ausnahme falsch'
$script:ServerDestinationPaths=@{}
$script:DestinationPath='D:\Tools\ndtrack'
Assert ((Resolve-WindowsFolder 'server01') -eq 'D:\Tools\ndtrack') 'Dynamischer Zielpfad falsch'
$rejected=$false
try { Resolve-WindowsFolder 'server;invalid' } catch { $rejected=$true }
Assert $rejected 'Ungueltiger Host akzeptiert'
$script:DestinationPath='C:\Tools\..\ndtrack'
$rejected=$false
try { Resolve-WindowsFolder 'server01' } catch { $rejected=$true }
Assert $rejected 'Pfad mit .. akzeptiert'
# Echte lokale Exitcodes; nur ein leerer PowerShell-Kindprozess.
$program=(Get-Process -Id $PID).Path
$rejected=$false
try { Invoke-NativeChecked $program @('-NoProfile','-Command','exit 7') } catch { $rejected=$true }
Assert $rejected 'Native Fehler nicht erkannt'
Invoke-NativeChecked $program @('-NoProfile','-Command','exit 0')
$script:checks++
# Alle acht Menueablaeufe mit eindeutigem Erfolg/Fehlschlag der vorgeschalteten Schritte.
function GetADServer { @('ok','failed') }
function GetRDSServer { @('rds01') }
function GetLinuxServer { @('linuxok','linuxfailed') }
function Get-LinuxUser { 'scanuser' }
function Get-Credential { [pscredential]::new('DOMAIN\scan',(ConvertTo-SecureString 'test-only' -AsPlainText -Force)) }
$script:trace=@()
function CopyFile { param($Servers) $script:trace+='copy'; 'ok' }
function RunNDTRACKRemotely { param($Servers) Assert (($Servers -join ',') -eq 'ok') 'Option 1 startet fehlgeschlagene Server'; $script:trace+='run' }
function CreateScheduledTask { param($Servers,$Credential) Assert (($Servers -join ',') -eq 'ok,failed') 'Option 2 erhaelt falsche Ziele'; $script:trace+='task' }
function CopyFileLinux { param($Servers,$User) Assert ($User -eq 'scanuser') 'Linux-Konto fehlt'; $script:trace+='linuxcopy'; 'linuxok' }
function RunNDTRACKRemotelyLinux { param($Servers,$User) Assert (($Servers -join ',') -eq 'linuxok,linuxfailed') 'Option 5 erhaelt falsche Ziele'; $script:trace+='linuxrun' }
function GetInventoryFiles { param($Servers) $script:trace+='collect' }
function GetInventoryFilesLinux { param($Servers,$User) Assert ($User -eq 'scanuser') 'Konto Option 5 fehlt'; $script:trace+='linuxcollect' }
function DeleteScheduledTask { param($Servers) $script:trace+='stoptask'; 'ok' }
function DeleteFile { param($Servers) Assert (($Servers -join ',') -eq 'ok') 'Option 6 loescht trotz Task-Fehler'; $script:trace+='delete' }
function DeleteFileLinux { param($Servers,$User) $script:trace+='linuxdelete' }
function Scan_RDS_SINA { param($Servers) Assert (($Servers -join ',') -eq 'rds01') 'RDS-Ziele falsch'; $script:trace+='rds' }
$expected=@('copy','task','collect','linuxcopy','linuxrun','linuxcollect','stoptask,delete','linuxdelete')
foreach($option in 1..8){
$script:trace=@()
Invoke-MenuOption ([string]$option)
Assert (($script:trace -join ',') -eq $expected[$option-1]) "Ablauf Option $option falsch"
Write-Host "Option ${option}: Ablauf bestanden"
}
function CopyFile { param($Servers) }
$script:trace=@(); Invoke-MenuOption '1'; Assert ($script:trace.Count -eq 0) 'Scan trotz leerer Kopiererfolge'
$script:trace=@(); Invoke-MenuOption '0'; Assert ($script:trace.Count -eq 0) 'Option 0 fuehrt Aktionen aus'
function Get-Credential { $null }
$rejected=$false
try { Invoke-MenuOption '2' } catch { $rejected=$true }
Assert $rejected 'Abgebrochene Kontoabfrage nicht erkannt'
Write-Host "$script:checks Pruefungen bestanden. Keine echten Zielsysteme getestet."
# Originalfunktionen erneut laden und deren Fehlerpfade pruefen.
. $path -LibraryOnly
$script:DestinationPath='C:\ndtrack'
$script:TaskName='NDTrackTask'
$script:WindowsLauncher='RunNdTrackWindows_Local.cmd'
$script:LinuxSourcePath='test-source'
$script:LinuxLauncher='RunNdTrackLinuxUnix_Local.sh'
$script:Ergebnisordner='test-results'
$script:StartDelayMinutes=5
function Test-Path { $true }
function Test-SourceFiles { }
function Join-Path { param($Path,$ChildPath) "$Path/$ChildPath" }
function Invoke-Command { throw 'Simulierter Remote-Fehler' }
function Invoke-LinuxCommand { throw 'Simulierter SSH-Fehler' }
$credential=[pscredential]::new('DOMAIN\scan',(ConvertTo-SecureString 'test-only' -AsPlainText -Force))
$cases=@(
{ CreateScheduledTask @('server01') $credential },
{ RunNDTRACKRemotely @('server01') },
{ DeleteScheduledTask @('server01') },
{ DeleteFile @('server01') },
{ GetInventoryFiles @('server01') },
{ CopyFileLinux @('server01') 'scanuser' },
{ RunNDTRACKRemotelyLinux @('server01') 'scanuser' },
{ GetInventoryFilesLinux @('server01') 'scanuser' },
{ DeleteFileLinux @('server01') 'scanuser' }
)
foreach($case in $cases){
$output=@(& $case *>&1)
Assert (@($output | Where-Object { $_ -is [System.Management.Automation.WarningRecord] }).Count -gt 0) 'Fehler wurde nicht gemeldet'
Assert (-not (($output | Out-String) -match 'START ANGEFORDERT:|GEPLANT:|BEENDET:|ENTFERNT:|EINGESAMMELT:|KOPIERT:')) 'Falsche Erfolgsmeldung nach Fehler'
}
Write-Host "Gesamt: $script:checks Pruefungen bestanden."
+33
View File
@@ -0,0 +1,33 @@
$ErrorActionPreference='Stop'
$preScript=Join-Path (Split-Path $PSScriptRoot -Parent) 'PreScript.ps1'
$root=Join-Path ([IO.Path]::GetTempPath()) ('ndtrack-pre-'+[guid]::NewGuid().ToString('N'))
$program=(Get-Process -Id $PID).Path
try {
& $program -NoProfile -File $preScript -BasePath $root
if($LASTEXITCODE -ne 1){throw 'Fehlende Ordner akzeptiert'}
if(Test-Path -LiteralPath $root){throw 'PreScript hat Ordner angelegt'}
foreach($relative in @('SCRIPT','NDTRACK','RESULTS','SCRIPT/Logs')){
New-Item -Path (Join-Path $root $relative) -ItemType Directory -Force | Out-Null
}
& $program -NoProfile -File $preScript -BasePath $root
if($LASTEXITCODE -ne 1){throw 'Leeres Paket akzeptiert'}
# Harmloses Test-Hauptskript dokumentiert nur seinen Start.
$fixture='Set-Content -LiteralPath (Join-Path $PSScriptRoot "started.txt") -Value "started"'
$main=Join-Path $root 'SCRIPT/NDTrack-Geprueft.ps1'
$marker=Join-Path $root 'SCRIPT/started.txt'
Set-Content -LiteralPath $main -Value $fixture
Set-Content -LiteralPath (Join-Path $root 'NDTRACK/RunNdTrackWindows_Local.cmd') -Value '@echo test'
& $program -NoProfile -File $preScript -BasePath $root
if($LASTEXITCODE -ne 0 -or -not(Test-Path -LiteralPath $marker)){throw 'Hauptskript nicht gestartet'}
Remove-Item -LiteralPath $marker
& $program -NoProfile -File $preScript -BasePath $root -Platform Both
if($LASTEXITCODE -ne 1 -or (Test-Path -LiteralPath $marker)){throw 'Start trotz fehlender Linux-Datei'}
Set-Content -LiteralPath (Join-Path $root 'NDTRACK/RunNdTrackLinuxUnix_Local.sh') -Value '#!/bin/sh'
& $program -NoProfile -File $preScript -BasePath $root -Platform Both
if($LASTEXITCODE -ne 0 -or -not(Test-Path -LiteralPath $marker)){throw 'Start fuer beide Plattformen fehlgeschlagen'}
Remove-Item -LiteralPath $marker
Set-Content -LiteralPath $main -Value 'function Broken {'
& $program -NoProfile -File $preScript -BasePath $root
if($LASTEXITCODE -ne 1 -or (Test-Path -LiteralPath $marker)){throw 'Syntaxfehler akzeptiert'}
Write-Host 'PreScript: 6 Szenarien bestanden; fehlende Ordner nicht angelegt; Hauptskript nur bei Erfolg gestartet.'
} finally { if(Test-Path -LiteralPath $root){Remove-Item -LiteralPath $root -Recurse -Force} }
+34
View File
@@ -0,0 +1,34 @@
$ErrorActionPreference='Stop'
. (Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1') -LibraryOnly
$script:DestinationPath=''; $script:ServerDestinationPaths=@{}
$script:removed=0; $script:wmiFail=$false
function New-CimSessionOption { param($Protocol,$ErrorAction) if($Protocol -ne 'Dcom'){throw 'WinRM statt DCOM verwendet'}; 'DCOM' }
function New-CimSession { param($ComputerName,$SessionOption,$ErrorAction) $ComputerName }
function Get-CimInstance { param($CimSession,$ClassName,$Property,$ErrorAction)
if($script:wmiFail){throw 'WMI nicht erreichbar'}
if($CimSession -eq 'sql01.example'){[pscustomobject]@{SystemDrive='D:'}}else{[pscustomobject]@{SystemDrive='C:'}}
}
function Remove-CimSession { $script:removed++ }
$script:SourcePath='source'; $script:WindowsLauncher='Run.cmd'
$script:copied=@(); $script:shareAvailable=$true
function Test-SourceFiles { }
function Invoke-Command { throw 'WinRM darf beim Kopieren nicht verwendet werden' }
function New-PSSession { throw 'Keine WinRM-Sitzung erlaubt' }
function Test-Path { param($LiteralPath,$PathType,$ErrorAction) if($LiteralPath -like '*.ndtrack-running'){return $false}; $script:shareAvailable }
function New-Item { }
function Get-ChildItem { [pscustomobject]@{Name='Run.cmd'} }
function Copy-Item { param([Parameter(ValueFromPipeline)]$InputObject,$Destination,[switch]$Recurse,[switch]$Force) process {$script:copied += $Destination} }
$result=@(CopyFile @('win01.example','sql01.example'))
if(($result -join ',') -ne 'win01.example,sql01.example'){throw 'Falsche Erfolgsrueckgabe'}
if(($script:copied -join ',') -ne '\\win01.example\C$\ndtrack,\\sql01.example\D$\ndtrack'){throw 'Falsche SMB-Ziele'}
$script:shareAvailable=$false; $script:copied=@()
$result=@(CopyFile @('win01.example'))
if($result.Count -or $script:copied.Count){throw 'Kopiert trotz fehlender Freigabe'}
Write-Host 'SMB-Kopieren: Standard C$, Ausnahme D$, Fehlerfall und keine WinRM-Aufrufe geprueft.'
$script:shareAvailable=$true; $script:wmiFail=$true; $script:copied=@()
$result=@(CopyFile @('sql01.example'))
if($result.Count -or $script:copied.Count){throw 'Kopiert trotz WMI-Fehler'}
if($script:removed -ne 4){throw 'CIM-Sitzungen nicht bereinigt'}
Write-Host 'Dynamische Laufwerke C:/D:, WMI-Fehler und Sitzungsbereinigung bestanden.'
+39
View File
@@ -0,0 +1,39 @@
$ErrorActionPreference = 'Stop'
. (Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1') -LibraryOnly
$root = Join-Path ([IO.Path]::GetTempPath()) ('ndtrack-test-' + [guid]::NewGuid().ToString('N'))
$script:checks=0
function Assert { param($Condition,$Message) if(-not $Condition){throw $Message}; $script:checks++ }
function Assert-Fails { param([scriptblock]$Action,[string]$Pattern)
$message=''
try { & $Action } catch { $message=$_.Exception.Message }
Assert ($message -like $Pattern) "Erwarteter Fehler fehlt: $Pattern / $message"
}
try {
$script:ScriptFolder=Join-Path $root 'SCRIPT'
$script:SourcePath=Join-Path $root 'NDTRACK'
$script:LinuxSourcePath=$script:SourcePath
$script:Ergebnisordner=Join-Path $root 'RESULTS'
$script:LogFolder=Join-Path $script:ScriptFolder 'Logs'
CheckDirectory
foreach($path in @($script:ScriptFolder,$script:SourcePath,$script:Ergebnisordner,$script:LogFolder)) {
Assert (Test-Path -LiteralPath $path -PathType Container) "Ordner fehlt: $path"
}
CheckDirectory # Wiederholbarer Aufruf
Assert-Fails { Test-SourceFiles $script:SourcePath } '*Keine Dateien*'
New-Item -Path (Join-Path $script:SourcePath 'empty') -ItemType Directory | Out-Null
Assert-Fails { Test-SourceFiles $script:SourcePath } '*Keine Dateien*'
Set-Content -LiteralPath (Join-Path $script:SourcePath 'payload.dat') -Value 'test'
Test-SourceFiles $script:SourcePath
$script:checks++
Assert-Fails { Test-SourceFiles $script:SourcePath 'Run.cmd' } '*Startdatei fehlt*'
[IO.File]::WriteAllText((Join-Path $script:SourcePath 'Run.cmd'),'')
Assert-Fails { Test-SourceFiles $script:SourcePath 'Run.cmd' } '*Startdatei ist leer*'
Set-Content -LiteralPath (Join-Path $script:SourcePath 'Run.cmd') -Value '@echo test'
Test-SourceFiles $script:SourcePath 'Run.cmd'
$script:checks++
$script:ScriptFolder=Join-Path $root 'file-instead-of-folder'
Set-Content -LiteralPath $script:ScriptFolder -Value 'keep'
Assert-Fails { CheckDirectory } '*Datei statt eines Ordners*'
Assert ((Get-Content -LiteralPath $script:ScriptFolder) -eq 'keep') 'Bestehende Datei veraendert'
Write-Host "$script:checks Ordner-/Dateipruefungen bestanden."
} finally { if(Test-Path -LiteralPath $root){Remove-Item -LiteralPath $root -Recurse -Force} }
+30
View File
@@ -0,0 +1,30 @@
$ErrorActionPreference='Stop'
. (Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1') -LibraryOnly
$script:TaskName='NDTRACK'; $script:WindowsLauncher='Run.cmd'
$script:events=@(); $script:hasFile=$true; $script:failCreate=$false
function Resolve-WindowsFolder { 'D:\ndtrack' }
function Invoke-Command { throw 'Kein WinRM erlaubt' }
function Test-Path { $script:hasFile }
function Get-Date { [datetime]'2026-10-15T14:00:00' }
function Invoke-NativeChecked { param($Program,$Arguments)
$script:events+=$Arguments[0]
if($Program -ne 'schtasks.exe' -or $Arguments[0] -ne '/Create'){throw 'Nicht Original-Erstellungsablauf'}
$expected=@{'/S'='server01';'/TN'='NDTRACK';'/TR'='D:\ndtrack\Run.cmd';'/SC'='Once';'/ST'='14:05';'/RU'='DOMAIN\scan';'/RP'='test-only';'/RL'='HIGHEST'}
foreach($key in $expected.Keys){if($Arguments[[array]::IndexOf($Arguments,$key)+1] -ne $expected[$key]){throw "Falsches Argument: $key"}}
if($Arguments -contains '/XML' -or $Arguments -contains '/Run'){throw 'XML oder Sofortstart unerwuenscht'}
if($script:failCreate){throw 'Exitcode 1'}
}
$credential=[pscredential]::new('DOMAIN\scan',(ConvertTo-SecureString 'test-only' -AsPlainText -Force))
CreateScheduledTask @('server01') $credential
if(($script:events -join ',') -ne '/Create'){throw 'Falsche Aufrufe'}
$script:events=@(); $script:hasFile=$false
CreateScheduledTask @('server01') $credential
if($script:events.Count){throw 'Task trotz fehlender CMD'}
$script:hasFile=$true; $script:failCreate=$true
$output=@(CreateScheduledTask @('server01') $credential *>&1)
if(($output | Out-String) -match 'GEPLANT:'){throw 'Falsche Erfolgsmeldung'}
$script:events=@()
function Get-Date { [datetime]'2026-10-15T23:58:00' }
CreateScheduledTask @('server01') $credential
if($script:events.Count){throw 'Ungueltige Planung ueber Tagesgrenze'}
Write-Host '4 Task-Szenarien bestanden; Originalargumente, Benutzerkonto, Exitcode-Fehler und Tagesgrenze geprueft.'
Binary file not shown.