# 5.1 Windows – Integrierte Werkzeuge zur Fehleranalyse
Windows stellt zahlreiche grafische Werkzeuge, Befehlszeilenprogramme und PowerShell-Cmdlets zur systematischen Fehleranalyse bereit. Damit lassen sich unter anderem Ereignisprotokolle, Prozesse, Dienste, Ressourcen, Datenträger, Netzwerkverbindungen, Systemdateien und Abstürze untersuchen.
Die Werkzeuge liefern jedoch zunächst nur Befunde. Einzelne Warnungen, hohe Messwerte oder Ereignis-IDs beweisen noch keine Ursache. Ergebnisse müssen immer mit Fehlerzeitpunkt, Symptomen, Änderungen und weiteren Datenquellen abgeglichen werden.
---
**Kennzeichnung der Befehle**
| Kennzeichnung | Bedeutung |
|---|---|
| `[RO]` | Nur lesender Befehl |
| `[TEST]` | Führt einen aktiven Test aus |
| `[CHANGE]` | Kann den Systemzustand verändern |
| `[PRIV]` | Erfordert möglicherweise administrative Rechte |
| `[SENS]` | Ausgabe kann sensible Informationen enthalten |
| `[RESTART]` | Neustart oder Unterbrechung möglich |
> Befehle mit `[CHANGE]`, `[RESTART]` oder `[SENS]` müssen vor ihrer Verwendung besonders sorgfältig geprüft werden.
---
1. Diagnosewerkzeuge gezielt auswählen
| Fragestellung | Geeignetes Werkzeug |
|---|---|
| Was geschah zum Fehlerzeitpunkt? | Ereignisanzeige, `Get-WinEvent` |
| Welcher Prozess belastet das System? | Task-Manager, Ressourcenmonitor, `Get-Process` |
| Welcher Dienst läuft nicht? | Diensteverwaltung, `Get-Service`, `sc.exe` |
| Welches Programm öffnet einen Port? | Ressourcenmonitor, `Get-NetTCPConnection`, `netstat` |
| Funktioniert die Namensauflösung? | `Resolve-DnsName`, `nslookup` |
| Ist ein TCP-Port erreichbar? | `Test-NetConnection` |
| Welche Route nimmt ein Paket? | `tracert`, `pathping` |
| Ist ein Datenträger voll? | Explorer, Datenträgerverwaltung, `Get-Volume` |
| Sind Windows-Systemdateien beschädigt? | SFC und DISM |
| Warum wurde Windows neu gestartet? | Ereignisanzeige, `Get-WinEvent` |
| Welche Treiber und Geräte sind vorhanden? | Geräte-Manager, `Get-PnpDevice`, `driverquery` |
| Wie entwickelt sich die Leistung über Zeit? | Leistungsüberwachung, Datenkollektorsätze |
| Welche Änderungen gingen der Störung voraus? | Zuverlässigkeitsverlauf, Updateverlauf, Ereignisprotokolle |
| Warum ist Windows abgestürzt? | Speicherabbild, WinDbg, Ereignisprotokolle |
**Grundregel**
1. Symptom und Zeitpunkt festhalten.
2. Umfang der Störung bestimmen.
3. Ereignisprotokolle zum betreffenden Zeitraum prüfen.
4. Ressourcen und betroffene Komponenten untersuchen.
5. Abhängigkeiten kontrollieren.
6. Erst danach Änderungen durchführen.
7. Ergebnis und Rückfallmöglichkeit dokumentieren.
2. Windows-Version und Systeminformationen erfassen
**Windows-Versionsdialog öffnen**
```cmd
[RO] winver
```
**Systeminformationen anzeigen**
```cmd
[RO][SENS] systeminfo
```
Die Ausgabe kann unter anderem Computername, Betriebssystemversion, Installationsdatum, Arbeitsspeicher, Domänenzugehörigkeit und installierte Hotfixes enthalten.
**Windows-Version mit PowerShell**
```powershell
[RO] Get-ComputerInfo |
Select-Object WindowsProductName,
WindowsVersion,
OsBuildNumber,
OsArchitecture
```
**Betriebssystem über CIM abfragen**
```powershell
[RO] Get-CimInstance Win32_OperatingSystem |
Select-Object Caption,
Version,
BuildNumber,
OSArchitecture,
LastBootUpTime
```
**Computer- und Hardwareinformationen**
```powershell
[RO][SENS] Get-ComputerInfo
```
**Systeminformationen grafisch öffnen**
```cmd
[RO] msinfo32
```
`msinfo32` enthält eine umfassende Übersicht über Hardware, Komponenten, Treiber, Ressourcen und die Softwareumgebung.
> Systeminformationen können Computername, Benutzerbezug, Netzwerkdaten und installierte Software offenlegen. Exporte müssen vor einer Weitergabe geprüft werden.
3. Ereignisanzeige verwenden
**Ereignisanzeige öffnen**
```cmd
[RO] eventvwr.msc
```
**Wichtige Windows-Protokolle**
| Protokoll | Typische Inhalte |
|---|---|
| Anwendung | Ereignisse von Programmen und Anwendungsdiensten |
| Sicherheit | Anmeldungen, Zugriffsprüfungen und Sicherheitsereignisse |
| Setup | Installation und Einrichtung von Windows-Komponenten |
| System | Treiber, Dienste, Hardware und Betriebssystemkomponenten |
| Weitergeleitete Ereignisse | Von anderen Computern empfangene Ereignisse |
Unter **Anwendungs- und Dienstprotokolle** befinden sich zusätzliche komponentenspezifische Protokolle, beispielsweise für PowerShell, Windows Defender, DNS, Gruppenrichtlinien oder Remotedesktopdienste.
**Ereignisstufen**
| Stufe | Bedeutung |
|---|---|
| Kritisch | Schwerwiegendes Ereignis, häufig mit Ausfall oder unerwartetem Neustart |
| Fehler | Eine Funktion oder Operation ist fehlgeschlagen |
| Warnung | Mögliches Problem oder auffälliger Zustand |
| Information | Regulärer Vorgang oder Statusmeldung |
| Ausführlich | Besonders detaillierte Diagnoseinformation |
**Wichtige Bewertungsregeln**
- Nicht jeder Fehler im Protokoll verursacht die untersuchte Störung.
- Eine hohe Zahl von Warnungen bedeutet nicht automatisch ein schwerwiegendes Problem.
- Ereignis-ID und Quelle müssen gemeinsam betrachtet werden.
- Derselbe Ereigniscode kann bei unterschiedlichen Quellen etwas anderes bedeuten.
- Der Zeitstempel muss zur tatsächlichen Störung passen.
- Folgefehler dürfen nicht mit der ursprünglichen Ursache verwechselt werden.
- Ereignisse vor dem sichtbaren Fehler sind häufig besonders wichtig.
- Ein unerwarteter Neustart kann ältere Protokolle oder flüchtige Zustände verändern.
**Benutzerdefinierte Ansicht erstellen**
1. **Ereignisanzeige** öffnen.
2. **Benutzerdefinierte Ansichten** auswählen.
3. **Benutzerdefinierte Ansicht erstellen** öffnen.
4. Zeitraum und Ereignisstufen festlegen.
5. Benötigte Protokolle oder Quellen auswählen.
6. Filter speichern und Ergebnisse chronologisch untersuchen.
> Das bloße Löschen eines Ereignisprotokolls behebt keine Ursache und vernichtet möglicherweise wichtige Diagnoseinformationen.
4. Windows-Ereignisse mit PowerShell untersuchen
**Verfügbare klassische Protokolle anzeigen**
```powershell
[RO] Get-WinEvent -ListLog * |
Select-Object LogName, RecordCount, IsEnabled
```
**Letzte 50 Systemereignisse**
```powershell
[RO][SENS] Get-WinEvent -LogName System -MaxEvents 50
```
**Fehler und kritische Ereignisse der letzten 24 Stunden**
```powershell
[RO][SENS] Get-WinEvent -FilterHashtable @{
LogName = 'System'
Level = 1, 2
StartTime = (Get-Date).AddHours(-24)
} | Select-Object TimeCreated, Id, ProviderName, LevelDisplayName, Message
```
**Ereignisse einer bestimmten Quelle**
```powershell
[RO][SENS] Get-WinEvent -FilterHashtable @{
LogName = 'System'
ProviderName = 'Service Control Manager'
StartTime = (Get-Date).AddDays(-1)
} | Select-Object TimeCreated, Id, LevelDisplayName, Message
```
**Bestimmte Ereignis-ID suchen**
```powershell
[RO][SENS] Get-WinEvent -FilterHashtable @{
LogName = 'System'
Id = 6008
StartTime = (Get-Date).AddDays(-7)
}
```
**Ergebnisse exportieren**
```powershell
[RO][SENS] Get-WinEvent -LogName System -MaxEvents 500 |
Export-Csv -Path ".\systemereignisse.csv" -NoTypeInformation -Encoding UTF8
```
> Exportierte Ereignisse können Benutzernamen, Computerbezeichnungen, Pfade, IP-Adressen und Anwendungsdaten enthalten.
**Vorteil von `FilterHashtable`**
Die Filterung erfolgt bereits beim Abruf. Das ist bei großen Ereignisprotokollen meist effizienter, als zunächst alle Ereignisse einzulesen und sie anschließend mit `Where-Object` zu filtern.
5. Häufig relevante Windows-Ereignisse einordnen
| Ereignis-ID | Typische Quelle | Grundsätzliche Bedeutung |
|---|---|---|
| `41` | Kernel-Power | Windows wurde ohne reguläres Herunterfahren neu gestartet |
| `1074` | User32 | Ein Prozess oder Benutzer leitete Herunterfahren oder Neustart ein |
| `6005` | EventLog | Ereignisprotokolldienst wurde gestartet |
| `6006` | EventLog | Ereignisprotokolldienst wurde regulär beendet |
| `6008` | EventLog | Vorheriges Herunterfahren war unerwartet |
| `7031` | Service Control Manager | Ein Dienst wurde unerwartet beendet |
| `7034` | Service Control Manager | Ein Dienst wurde unerwartet beendet |
| `7040` | Service Control Manager | Starttyp eines Dienstes wurde geändert |
| `7045` | Service Control Manager | Ein Dienst wurde im System installiert |
> Die Ereignis-ID allein ist kein vollständiger Befund. Quelle, Meldung, Zeitpunkt, betroffene Komponente und benachbarte Ereignisse müssen zusätzlich ausgewertet werden.
Ein Ereignis `Kernel-Power 41` bestätigt beispielsweise, dass Windows zuvor nicht ordnungsgemäß heruntergefahren wurde. Es beweist jedoch nicht, ob Stromverlust, Hardwarefehler, Absturz, erzwungenes Ausschalten oder eine andere Ursache verantwortlich war.
6. Zuverlässigkeitsverlauf auswerten
**Zuverlässigkeitsüberwachung öffnen**
```cmd
[RO] perfmon /rel
```
Der Zuverlässigkeitsverlauf stellt wichtige Ereignisse nach Tagen geordnet dar. Dazu können gehören:
- Anwendungsabstürze
- Windows-Fehler
- fehlgeschlagene Updates
- Treiberinstallationen
- Softwareinstallationen
- erfolgreiche Updates
- Hardwarefehler
**Sinnvolle Vorgehensweise**
1. Tag und Uhrzeit der Störung auswählen.
2. Kritische Ereignisse untersuchen.
3. Gleichzeitig installierte Updates oder Anwendungen beachten.
4. Technische Details öffnen.
5. Befund mit Ereignisanzeige und Anwendungsprotokollen vergleichen.
> Der Stabilitätsindex ist eine verdichtete Kennzahl. Er beweist nicht, welche Komponente die Ursache einer Störung ist.
7. Task-Manager zur ersten Eingrenzung verwenden
**Task-Manager öffnen**
```cmd
[RO] taskmgr
```
**Wichtige Bereiche**
| Registerkarte | Verwendung |
|---|---|
| Prozesse | Momentane CPU-, RAM-, Datenträger-, Netzwerk- und GPU-Nutzung |
| Leistung | Gesamtauslastung und zeitliche Kurzansicht |
| App-Verlauf | Ressourcennutzung unterstützter Apps |
| Autostart-Apps | Programme beim Benutzerstart |
| Benutzer | Ressourcen nach angemeldeten Benutzern |
| Details | Prozesse mit PID, Status, Benutzer und weiteren Spalten |
| Dienste | Dienststatus und zugehörige Informationen |
**Bei hoher Auslastung prüfen**
- Ist die Auslastung dauerhaft oder nur kurzfristig?
- Welcher Prozess verursacht sie?
- Gehört der Prozess zu einer Anwendung oder einem Windows-Dienst?
- Steigt der Speicherverbrauch fortlaufend?
- Liegt die Datenträgeraktivität bei hoher Antwortzeit?
- Wird ein Prozess mehrfach ausgeführt?
- Ist die Auslastung Folge eines Updates, Scans oder Backups?
- Stimmt der Fehlerzeitpunkt mit der Auslastung überein?
> Das sofortige Beenden eines unbekannten Prozesses kann Datenverlust verursachen oder Systemfunktionen unterbrechen.
8. Prozesse mit PowerShell untersuchen
**Prozesse anzeigen**
```powershell
[RO][SENS] Get-Process
```
**Prozesse nach CPU-Zeit sortieren**
```powershell
[RO][SENS] Get-Process |
Sort-Object CPU -Descending |
Select-Object -First 15 Name, Id, CPU, WorkingSet64
```
`CPU` enthält die bisher verbrauchte Prozessorzeit und nicht unmittelbar die aktuelle prozentuale CPU-Auslastung.
**Prozesse nach Arbeitsspeicher sortieren**
```powershell
[RO][SENS] Get-Process |
Sort-Object WorkingSet64 -Descending |
Select-Object -First 15 Name,
Id,
@{Name='RAM_MiB';Expression={[math]::Round($_.WorkingSet64 / 1MB, 1)}}
```
**Bestimmten Prozess anzeigen**
```powershell
[RO][SENS] Get-Process -Id
```
**Prozessdetails über CIM**
```powershell
[RO][SENS] Get-CimInstance Win32_Process -Filter "ProcessId=" |
Select-Object ProcessId, ParentProcessId, Name, ExecutablePath, CommandLine
```
Die Befehlszeile kann Pfade, Benutzerdaten, Servernamen oder sogar ungeschützt übergebene Zugangsdaten enthalten.
**Prozess kontrolliert beenden**
```powershell
[CHANGE] Stop-Process -Id
```
**Erzwungenes Beenden**
```powershell
[CHANGE] Stop-Process -Id -Force
```
> `-Force` darf nicht als allgemeine Fehlerbehebung verwendet werden. Nicht gespeicherte Daten können verloren gehen und abhängige Komponenten können ausfallen.
9. Ressourcenmonitor verwenden
**Ressourcenmonitor öffnen**
```cmd
[RO] resmon
```
Der Ressourcenmonitor zeigt detaillierte Informationen zu:
- CPU
- Arbeitsspeicher
- Datenträgeraktivität
- Netzwerkaktivität
- TCP-Verbindungen
- lauschenden Ports
- Prozessen und zugehörigen Dateien
**Typische Anwendungsfälle**
- Prozess mit hoher Datenträgeraktivität bestimmen
- Datei mit vielen Zugriffen ermitteln
- Prozess hinter einer TCP-Verbindung identifizieren
- lauschenden Port einer Anwendung feststellen
- Hard Faults und Speichernutzung untersuchen
- Abhängigkeiten eines angehaltenen Prozesses betrachten
> Ein Hard Fault ist nicht automatisch ein Hardwarefehler. Er bezeichnet in diesem Zusammenhang einen Speicherzugriff, bei dem benötigte Daten nicht im physischen Arbeitsspeicher vorlagen und aus einer anderen Speicherquelle geladen werden mussten.
10. Leistungsüberwachung und Performance Counter
**Leistungsüberwachung öffnen**
```cmd
[RO] perfmon
```
Die Leistungsüberwachung kann Messwerte in Echtzeit anzeigen oder über Datenkollektorsätze längerfristig erfassen.
**Verfügbare Leistungsindikatoren mit PowerShell anzeigen**
```powershell
[RO] Get-Counter -ListSet *
```
**Einzelne Messung durchführen**
```powershell
[TEST] Get-Counter '\Processor(_Total)\% Processor Time'
```
**Mehrere Messwerte erfassen**
```powershell
[TEST] Get-Counter `
'\Processor(_Total)\% Processor Time',
'\Memory\Available MBytes',
'\PhysicalDisk(_Total)\Avg. Disk sec/Transfer' `
-SampleInterval 2 `
-MaxSamples 10
```
**Wichtige Kategorien**
| Kategorie | Beispiele |
|---|---|
| Processor | Gesamtauslastung und Prozessorzeit |
| Memory | verfügbarer Speicher und Paging |
| PhysicalDisk | Warteschlangen, Übertragungen und Latenz |
| Network Interface | übertragene und verworfene Daten |
| Process | Werte einzelner Prozesse |
| System | Prozesse, Threads und Systemaktivität |
**Bewertungsregeln**
- Einzelmessungen bilden nur einen kurzen Zeitpunkt ab.
- Grenzwerte hängen von Arbeitslast, Hardware und Anwendung ab.
- Durchschnittswerte können kurze Lastspitzen verdecken.
- Eine hohe Warteschlange beweist ohne Latenz- und Durchsatzwerte noch keinen Datenträgerdefekt.
- Prozessinstanzen können sich bei einem Neustart oder mehreren gleichnamigen Prozessen ändern.
- Messung und Fehler müssen zeitlich zusammenpassen.
11. Dienste untersuchen
**Diensteverwaltung öffnen**
```cmd
[RO] services.msc
```
**Alle Dienste mit PowerShell anzeigen**
```powershell
[RO] Get-Service
```
**Beendete Dienste anzeigen**
```powershell
[RO] Get-Service |
Where-Object Status -eq 'Stopped'
```
Ein beendeter Dienst ist nicht automatisch fehlerhaft. Viele Dienste werden nur bei Bedarf gestartet.
**Bestimmten Dienst prüfen**
```powershell
[RO] Get-Service -Name ""
```
**Ausführlichere Dienstinformationen**
```powershell
[RO][SENS] Get-CimInstance Win32_Service -Filter "Name=''" |
Select-Object Name,
DisplayName,
State,
StartMode,
StartName,
PathName,
ProcessId
```
**Dienstkonfiguration mit `sc.exe`**
```cmd
[RO] sc.exe qc ""
```
**Dienstabhängigkeiten**
```powershell
[RO] Get-Service -Name "" -RequiredServices
```
**Abhängige Dienste**
```powershell
[RO] Get-Service -Name "" -DependentServices
```
**Dienst starten**
```powershell
[CHANGE][PRIV] Start-Service -Name ""
```
**Dienst neu starten**
```powershell
[CHANGE][PRIV][RESTART] Restart-Service -Name ""
```
> Vor einem Dienstneustart müssen abhängige Anwendungen, aktive Benutzer, Transaktionen und Auswirkungen auf andere Systeme geprüft werden.
12. Netzwerkgrundlagen erfassen
**Vollständige IP-Konfiguration**
```cmd
[RO][SENS] ipconfig /all
```
**PowerShell-Netzwerkkonfiguration**
```powershell
[RO][SENS] Get-NetIPConfiguration
```
**IP-Adressen anzeigen**
```powershell
[RO][SENS] Get-NetIPAddress
```
**Netzwerkadapter anzeigen**
```powershell
[RO] Get-NetAdapter |
Select-Object Name, InterfaceDescription, Status, LinkSpeed, MacAddress
```
**Routingtabelle anzeigen**
```cmd
[RO][SENS] route print
```
Alternativ:
```powershell
[RO][SENS] Get-NetRoute |
Sort-Object InterfaceIndex, DestinationPrefix
```
**DNS-Server anzeigen**
```powershell
[RO][SENS] Get-DnsClientServerAddress
```
**Wichtige Prüfwerte**
- erwartete IPv4- oder IPv6-Adresse
- Präfix beziehungsweise Subnetzmaske
- Standardgateway
- DNS-Server
- DHCP-Status
- Adapterstatus
- Verbindungsgeschwindigkeit
- unerwartete virtuelle Adapter
- VPN- oder Hypervisor-Routen
- APIPA-Adresse aus `169.254.0.0/16`
> Eine APIPA-Adresse kann darauf hinweisen, dass keine erwartete IPv4-Konfiguration per DHCP bezogen wurde. Sie beweist jedoch nicht allein, warum der DHCP-Vorgang scheiterte.
13. Erreichbarkeit und Netzwerkpfad testen
**Lokalen TCP/IP-Stack testen**
```cmd
[TEST] ping 127.0.0.1
```
**Standardgateway testen**
```cmd
[TEST] ping
```
**Ziel testen**
```cmd
[TEST] ping
```
**Route zum Ziel verfolgen**
```cmd
[TEST][SENS] tracert
```
**Verlust und Laufzeit entlang des Pfades untersuchen**
```cmd
[TEST][SENS] pathping
```
**TCP-Port mit PowerShell testen**
```powershell
[TEST][SENS] Test-NetConnection -ComputerName "" -Port
```
Beispiel:
```powershell
[TEST][SENS] Test-NetConnection -ComputerName "server.example" -Port 443
```
**Erweiterte Verbindungsinformationen**
```powershell
[TEST][SENS] Test-NetConnection -ComputerName "" -DiagnoseRouting -InformationLevel Detailed
```
**Bewertungsregeln**
- Ein fehlgeschlagener Ping beweist nicht, dass das Ziel ausgefallen ist.
- ICMP kann gefiltert werden, während ein Anwendungsport erreichbar bleibt.
- Ein erfolgreicher Ping beweist nicht, dass die Anwendung funktioniert.
- Ein erfolgreicher TCP-Test bestätigt die Verbindung zum getesteten Port, aber nicht automatisch eine korrekte Anwendungssitzung.
- Zeitüberschreitungen bei `tracert` können durch gefilterte Antworten entstehen.
- Paketverlust an einem Zwischenknoten ist nur dann aussagekräftig, wenn er sich bis zum Ziel fortsetzt.
14. DNS-Auflösung untersuchen
**DNS-Abfrage mit PowerShell**
```powershell
[TEST][SENS] Resolve-DnsName ""
```
**Bestimmten DNS-Server abfragen**
```powershell
[TEST][SENS] Resolve-DnsName "" -Server ""
```
**Klassische DNS-Abfrage**
```cmd
[TEST][SENS] nslookup
```
**DNS-Clientcache anzeigen**
```powershell
[RO][SENS] Get-DnsClientCache
```
Alternativ:
```cmd
[RO][SENS] ipconfig /displaydns
```
**DNS-Clientcache leeren**
```powershell
[CHANGE][PRIV] Clear-DnsClientCache
```
Alternativ:
```cmd
[CHANGE][PRIV] ipconfig /flushdns
```
**Typische Fehlerquellen**
- falscher DNS-Server
- falscher oder abgelaufener DNS-Eintrag
- Suchsuffix fehlt
- Split-DNS liefert abhängig vom Standort andere Antworten
- VPN überschreibt DNS-Einstellungen
- lokaler Cache enthält einen alten Eintrag
- Hosts-Datei überschreibt DNS
- Firewall blockiert DNS-Abfragen
- IPv4- und IPv6-Antworten führen zu unterschiedlichen Pfaden
> Das Leeren des DNS-Caches sollte nur erfolgen, wenn ein veralteter lokaler Cache als Ursache infrage kommt. Es behebt keine falschen Einträge auf dem DNS-Server.
15. Ports und Verbindungen untersuchen
**TCP-Verbindungen anzeigen**
```powershell
[RO][SENS] Get-NetTCPConnection
```
**Lauschende TCP-Ports**
```powershell
[RO][SENS] Get-NetTCPConnection -State Listen |
Sort-Object LocalPort |
Select-Object LocalAddress, LocalPort, OwningProcess
```
**Zugehörigen Prozess bestimmen**
```powershell
[RO][SENS] Get-Process -Id
```
**Klassische Portübersicht**
```cmd
[RO][SENS] netstat -ano
```
**Lauschende Ports**
```cmd
[RO][SENS] netstat -ano | findstr LISTENING
```
**Ausführbare Programme einbeziehen**
```cmd
[RO][PRIV][SENS] netstat -abno
```
**UDP-Endpunkte**
```powershell
[RO][SENS] Get-NetUDPEndpoint |
Sort-Object LocalPort
```
**Wichtige Zustände**
| Zustand | Bedeutung |
|---|---|
| `Listen` | Prozess wartet auf eingehende TCP-Verbindungen |
| `Established` | TCP-Verbindung besteht |
| `TimeWait` | Verbindung wurde beendet und bleibt vorübergehend gespeichert |
| `SynSent` | Verbindungsaufbau wurde begonnen, Antwort steht noch aus |
| `CloseWait` | Gegenstelle hat beendet; lokaler Prozess muss noch schließen |
> Ein offener Hostport beweist noch nicht, dass die Anwendung fachlich korrekt arbeitet. Zusätzlich müssen Protokoll, Antwort und gegebenenfalls Authentifizierung getestet werden.
16. Windows-Firewall untersuchen
**Firewallprofile anzeigen**
```powershell
[RO] Get-NetFirewallProfile |
Select-Object Name, Enabled, DefaultInboundAction, DefaultOutboundAction
```
**Aktivierte Firewallregeln anzeigen**
```powershell
[RO][SENS] Get-NetFirewallRule -Enabled True |
Select-Object DisplayName, Direction, Action, Profile
```
**Regeln anhand eines Namens suchen**
```powershell
[RO][SENS] Get-NetFirewallRule |
Where-Object DisplayName -Like '**'
```
**Firewallverwaltung öffnen**
```cmd
[RO] wf.msc
```
**Typische Prüfpunkte**
- aktives Netzwerkprofil
- Eingangs- oder Ausgangsrichtung
- erlaubende und blockierende Regeln
- lokaler Port und Remoteport
- lokales und entferntes Adressnetz
- zugeordnetes Programm oder Dienst
- Domänen-, privates oder öffentliches Profil
- zentral durch Gruppenrichtlinie verwaltete Regeln
> Die Firewall darf nicht pauschal deaktiviert werden, um ein Verbindungsproblem zu testen. Stattdessen muss die konkrete Verbindung mit passender Protokollierung und eng begrenzten Regeln untersucht werden.
17. Datenträger, Volumes und Speicherplatz prüfen
**Volumes anzeigen**
```powershell
[RO] Get-Volume |
Select-Object DriveLetter,
FileSystemLabel,
FileSystem,
HealthStatus,
SizeRemaining,
Size
```
**Datenträger anzeigen**
```powershell
[RO] Get-Disk
```
**Partitionen anzeigen**
```powershell
[RO] Get-Partition
```
**Freien Speicher übersichtlich berechnen**
```powershell
[RO] Get-Volume |
Where-Object DriveLetter |
Select-Object DriveLetter,
FileSystemLabel,
@{Name='Frei_GiB';Expression={[math]::Round($_.SizeRemaining / 1GB, 2)}},
@{Name='Gesamt_GiB';Expression={[math]::Round($_.Size / 1GB, 2)}}
```
**Datenträgerverwaltung öffnen**
```cmd
[RO] diskmgmt.msc
```
**Dateisystem online prüfen**
```cmd
[TEST][PRIV] chkdsk C: /scan
```
**Wichtige Unterscheidungen**
- Freier Speicherplatz ist nicht dasselbe wie Datenträgerzustand.
- Ein Zustand `Healthy` schließt nicht jede Hardwarestörung aus.
- Ein voller Datenträger kann Updates, Protokollierung, Datenbanken und Benutzeranmeldungen beeinträchtigen.
- Eine hohe Datenträgerauslastung bedeutet nicht automatisch, dass das Laufwerk defekt ist.
- Dateisystemfehler, Hardwarefehler, Controllerprobleme und Anwendungs-I/O müssen getrennt untersucht werden.
> Reparaturoptionen wie `chkdsk /f` oder `/r` können lange Laufzeiten, exklusive Datenträgerzugriffe oder einen Neustart erfordern. Sie dürfen nicht ohne Sicherung und Wartungsplanung eingesetzt werden.
18. Arbeitsspeicher untersuchen
**Grundlegende Speicherinformationen**
```powershell
[RO] Get-CimInstance Win32_OperatingSystem |
Select-Object @{
Name='Gesamt_GiB'
Expression={[math]::Round($_.TotalVisibleMemorySize / 1MB, 2)}
}, @{
Name='Frei_GiB'
Expression={[math]::Round($_.FreePhysicalMemory / 1MB, 2)}
}
```
**Installierte Speichermodule**
```powershell
[RO][SENS] Get-CimInstance Win32_PhysicalMemory |
Select-Object BankLabel,
DeviceLocator,
Capacity,
Speed,
Manufacturer,
PartNumber
```
**Windows-Speicherdiagnose öffnen**
```cmd
[TEST][RESTART] mdsched.exe
```
Die Speicherdiagnose bietet normalerweise einen Test beim nächsten Neustart oder einen sofortigen Neustart mit anschließender Prüfung an.
> Ein Speicherdiagnosetest unter Last oder ein einzelner erfolgreicher Durchlauf schließt sporadische Hardwarefehler nicht zwingend aus.
19. Geräte und Treiber prüfen
**Geräte-Manager öffnen**
```cmd
[RO] devmgmt.msc
```
**Vorhandene Plug-and-Play-Geräte**
```powershell
[RO][SENS] Get-PnpDevice
```
**Geräte mit Fehlerstatus**
```powershell
[RO][SENS] Get-PnpDevice |
Where-Object Status -ne 'OK'
```
**Installierte Treiber**
```cmd
[RO][SENS] driverquery /v
```
**Signierte Treiber mit PowerShell**
```powershell
[RO][SENS] Get-CimInstance Win32_PnPSignedDriver |
Select-Object DeviceName,
DriverVersion,
DriverDate,
Manufacturer,
InfName
```
**Typische Prüfpunkte**
- Gerätestatus und Fehlercode
- Treiberversion und Treiberdatum
- kürzlich erfolgte Treiberänderung
- unbekannte oder deaktivierte Geräte
- Hardware-ID
- Herstellerfreigabe für die Windows-Version
- Zusammenhang zwischen Treiberinstallation und Fehlerzeitpunkt
> Ein neuerer Treiber ist nicht automatisch geeigneter. Entscheidend sind Hardwaremodell, Betriebssystemversion und Freigabe durch Hersteller oder Geräteanbieter.
20. Autostart, Aufgaben und Systemstart untersuchen
**Autostartprogramme über CIM anzeigen**
```powershell
[RO][SENS] Get-CimInstance Win32_StartupCommand |
Select-Object Name, Command, Location, User
```
**Aufgabenplanung öffnen**
```cmd
[RO] taskschd.msc
```
**Geplante Aufgaben anzeigen**
```powershell
[RO][SENS] Get-ScheduledTask |
Select-Object TaskPath, TaskName, State
```
**Aufgaben mit letztem Ergebnis**
```powershell
[RO][SENS] Get-ScheduledTask | ForEach-Object {
$info = $_ | Get-ScheduledTaskInfo
[PSCustomObject]@{
TaskPath = $_.TaskPath
TaskName = $_.TaskName
State = $_.State
LastRunTime = $info.LastRunTime
LastTaskResult = $info.LastTaskResult
NextRunTime = $info.NextRunTime
}
}
```
**Systemkonfiguration öffnen**
```cmd
[RO] msconfig
```
> Autostarteinträge und geplante Aufgaben dürfen nicht wahllos deaktiviert werden. Sie können zu Sicherheitssoftware, Backups, Updates, Treibern oder geschäftskritischen Anwendungen gehören.
21. Windows-Updates prüfen
**Installierte Hotfixes anzeigen**
```powershell
[RO] Get-HotFix |
Sort-Object InstalledOn -Descending
```
**Updateverlauf in den Einstellungen**
```text
Einstellungen
→ Windows Update
→ Updateverlauf
```
**Windows-Update-Ereignisse abrufen**
```powershell
[RO][SENS] Get-WinEvent -LogName `
'Microsoft-Windows-WindowsUpdateClient/Operational' `
-MaxEvents 100 |
Select-Object TimeCreated, Id, LevelDisplayName, Message
```
**Typische Prüfpunkte**
- Zeitpunkt der Installation
- KB-Nummer
- erfolgreicher oder fehlgeschlagener Abschluss
- erforderlicher Neustart
- Treiberupdate
- bekannte Abhängigkeit zur betroffenen Anwendung
- wiederholt fehlgeschlagene Installation
- ausreichend freier Speicher
- Richtlinien oder Updateverwaltung im Unternehmen
> Ein zeitlicher Zusammenhang zwischen Update und Fehler ist ein wichtiger Hinweis, aber noch kein Ursachennachweis. Vor einer Deinstallation müssen bekannte Probleme, Sicherheitsfolgen und Herstellerangaben geprüft werden.
22. Windows-Systemdateien mit SFC prüfen
Der System File Checker überprüft geschützte Windows-Systemdateien und kann beschädigte Dateien ersetzen.
**Systemdateien prüfen und reparieren**
```cmd
[CHANGE][PRIV] sfc /scannow
```
**Nur eine bestimmte Datei prüfen**
```cmd
[TEST][PRIV] sfc /verifyfile=""
```
**Nur prüfen, ohne Reparatur**
```cmd
[TEST][PRIV] sfc /verifyonly
```
**Mögliche Ergebnisse**
- Keine Integritätsverletzungen gefunden
- Beschädigte Dateien gefunden und erfolgreich repariert
- Beschädigte Dateien gefunden, aber nicht alle repariert
- Prüfung konnte nicht ausgeführt werden
**SFC-Einträge aus dem CBS-Protokoll filtern**
```cmd
[RO][PRIV][SENS] findstr /c:"[SR]" %windir%\Logs\CBS\CBS.log
```
> SFC ist kein universelles Reparaturprogramm. Es untersucht geschützte Windows-Systemdateien, nicht automatisch Anwendungsdateien, Benutzerdaten, Hardware oder sämtliche Konfigurationen.
23. Windows-Komponentenspeicher mit DISM prüfen
DISM kann den Zustand des Windows-Abbilds beziehungsweise Komponentenspeichers untersuchen und reparieren.
**Schnelle Statusprüfung**
```cmd
[RO][PRIV] DISM /Online /Cleanup-Image /CheckHealth
```
**Ausführliche Prüfung**
```cmd
[TEST][PRIV] DISM /Online /Cleanup-Image /ScanHealth
```
**Windows-Abbild reparieren**
```cmd
[CHANGE][PRIV] DISM /Online /Cleanup-Image /RestoreHealth
```
**Bedeutung der Parameter**
| Parameter | Bedeutung |
|---|---|
| `/Online` | Aktuell laufendes Windows wird bearbeitet |
| `/Cleanup-Image` | Wartungsfunktion für das Windows-Abbild |
| `/CheckHealth` | Prüft, ob eine Beschädigung bereits erkannt wurde |
| `/ScanHealth` | Führt eine ausführlichere Prüfung durch |
| `/RestoreHealth` | Versucht erkannte Beschädigungen zu reparieren |
**Wichtige Hinweise**
- `/RestoreHealth` verändert den Systemzustand.
- Der Vorgang kann längere Zeit dauern.
- Eine Reparaturquelle kann erforderlich sein.
- Die Quelle muss zum installierten Windows passen.
- Fehler müssen anhand des DISM-Protokolls ausgewertet werden.
- Nach erfolgreicher Reparatur kann eine erneute SFC-Prüfung sinnvoll sein.
**DISM-Protokoll**
```text
C:\Windows\Logs\DISM\dism.log
```
**CBS-Protokoll**
```text
C:\Windows\Logs\CBS\CBS.log
```
> DISM und SFC dürfen nicht reflexartig bei jedem Windows-Problem ausgeführt werden. Zuerst sollte ein Zusammenhang mit beschädigten Windows-Komponenten oder Systemdateien begründet werden.
24. Gruppenrichtlinien und Richtlinienanwendung prüfen
**Angewendete Richtlinien anzeigen**
```cmd
[RO][SENS] gpresult /r
```
**Ausführlichen HTML-Bericht erzeugen**
```cmd
[RO][SENS] gpresult /h ".\gpresult.html"
```
**Resultant Set of Policy öffnen**
```cmd
[RO][SENS] rsop.msc
```
**Gruppenrichtlinien-Ereignisse**
```powershell
[RO][SENS] Get-WinEvent -LogName `
'Microsoft-Windows-GroupPolicy/Operational' `
-MaxEvents 100 |
Select-Object TimeCreated, Id, LevelDisplayName, Message
```
**Gruppenrichtlinien aktualisieren**
```cmd
[CHANGE][PRIV] gpupdate /force
```
> `gpupdate /force` kann Richtlinien erneut anwenden, Anmelde- oder Neustartanforderungen auslösen und den Arbeitszustand beeinflussen. Der Befehl ist kein Ersatz für die Analyse einer fehlerhaften Richtlinie.
25. Anmeldungen und Benutzerkontext untersuchen
**Aktuellen Benutzer anzeigen**
```cmd
[RO] whoami
```
**Gruppen und Sicherheitskennungen anzeigen**
```cmd
[RO][SENS] whoami /groups
```
**Aktuelle Berechtigungen anzeigen**
```cmd
[RO][SENS] whoami /priv
```
**Angemeldete Sitzungen**
```cmd
[RO][SENS] query user
```
**Lokale Benutzer anzeigen**
```powershell
[RO][SENS] Get-LocalUser
```
**Lokale Gruppenmitgliedschaften**
```powershell
[RO][SENS] Get-LocalGroupMember -Group ""
```
**Kerberos-Tickets anzeigen**
```cmd
[RO][SENS] klist
```
**Typische Ursachen kontextabhängiger Fehler**
- anderer Benutzer
- fehlende Gruppenmitgliedschaft
- nicht aktualisiertes Zugriffstoken
- lokale statt Domänenanmeldung
- abgelaufenes oder fehlendes Kerberos-Ticket
- Dienst läuft unter anderem Konto
- unterschiedliche Umgebungsvariablen
- abweichendes Benutzerprofil
- erhöhte und nicht erhöhte Sitzung besitzen unterschiedliche Rechte
> Ein erfolgreicher Test als Administrator beweist nicht, dass die Funktion für den vorgesehenen Benutzer korrekt berechtigt ist.
26. Remotedienste und Freigaben prüfen
**SMB-Freigaben anzeigen**
```powershell
[RO][SENS] Get-SmbShare
```
**Bestehende SMB-Verbindungen**
```powershell
[RO][SENS] Get-SmbConnection
```
**Erreichbarkeit von SMB testen**
```powershell
[TEST][SENS] Test-NetConnection -ComputerName "" -Port 445
```
**Remotedesktopport testen**
```powershell
[TEST][SENS] Test-NetConnection -ComputerName "" -Port 3389
```
**WinRM-Konfiguration anzeigen**
```cmd
[RO][SENS] winrm get winrm/config
```
**WinRM-Verbindung testen**
```powershell
[TEST][SENS] Test-WSMan -ComputerName ""
```
**Wichtige Unterscheidung**
Eine erfolgreiche TCP-Verbindung bestätigt nur, dass der getestete Port erreichbar ist. Sie bestätigt nicht automatisch:
- erfolgreiche Authentifizierung
- korrekte Freigabeberechtigung
- NTFS-Berechtigung
- funktionierende Remotedesktopsitzung
- gültiges Zertifikat
- erfolgreiche Anwendungskommunikation
27. Abstürze und Speicherabbilder untersuchen
Windows kann bei System- oder Anwendungsabstürzen Speicherabbilder erzeugen.
**Typische Speicherorte**
```text
C:\Windows\MEMORY.DMP
C:\Windows\Minidump\
%LOCALAPPDATA%\CrashDumps\
```
Die tatsächliche Konfiguration und der Speicherort können abweichen.
**Start- und Wiederherstellungseinstellungen öffnen**
```cmd
[RO] sysdm.cpl
```
Danach:
```text
Erweitert
→ Starten und Wiederherstellen
→ Einstellungen
```
**Typische Abbildarten**
| Typ | Inhalt |
|---|---|
| Kleines Speicherabbild | Begrenzte Informationen zum Absturz |
| Kernelspeicherabbild | Kernelbezogene Speicherbereiche |
| Automatisches Speicherabbild | Von Windows verwaltete Auswahl |
| Vollständiges Speicherabbild | Umfassender Inhalt des physischen Speichers |
| Aktives Speicherabbild | Für aktive Kernel- und Systembereiche optimiert |
**Wichtige Sicherheitsregel**
Speicherabbilder können enthalten:
- Benutzerdaten
- Dateiinhalte
- Prozessspeicher
- Schlüsselmaterial
- Tokens
- Passwörter oder andere Geheimnisse
- Netzwerk- und Sitzungsinformationen
> Speicherabbilder müssen wie sensible Diagnosedaten behandelt und dürfen nicht ungeprüft weitergegeben werden.
Zur detaillierten Analyse kann Microsoft WinDbg eingesetzt werden. WinDbg wird auf einer späteren Seite zusammen mit weiteren spezialisierten Werkzeugen behandelt.
28. Abgesicherter Modus und sauberer Systemstart
Der abgesicherte Modus startet Windows mit einer eingeschränkten Auswahl von Treibern und Diensten. Damit kann geprüft werden, ob ein Fehler durch zusätzliche Software, Treiber oder Autostartkomponenten beeinflusst wird.
Ein sauberer Systemstart deaktiviert gezielt nicht benötigte Dienste und Autostartprogramme, um Konflikte einzugrenzen.
**Systemkonfiguration öffnen**
```cmd
[CHANGE][RESTART] msconfig
```
**Wichtige Risiken**
- Sicherheits- oder Verwaltungssoftware kann vorübergehend deaktiviert werden.
- Geschäftsanwendungen oder Hintergrunddienste können ausfallen.
- Änderungen müssen dokumentiert und anschließend zurückgenommen werden.
- Abgesicherter Modus und sauberer Start sind Diagnosezustände, keine dauerhafte Lösung.
- In verwalteten Umgebungen kann eine Freigabe erforderlich sein.
**Geeignete Fragestellung**
```text
Tritt der Fehler auch mit einer minimalen Auswahl von Treibern,
Diensten und Autostartprogrammen auf?
```
Ein ausbleibender Fehler grenzt die Ursache ein, identifiziert aber noch nicht automatisch die verantwortliche Komponente.
29. Fernzugriff und Datensammlung sicher durchführen
Vor einer Ferndiagnose müssen geklärt werden:
- korrekter Zielcomputer
- berechtigte Person
- Wartungs- oder Diagnosefenster
- Auswirkungen auf aktive Benutzer
- erlaubte Werkzeuge
- Speicherort der Diagnosedaten
- Schutz sensibler Informationen
- Rückfallplan für Änderungen
**Computername prüfen**
```powershell
[RO] $env:COMPUTERNAME
```
**Benutzerkontext prüfen**
```powershell
[RO] whoami
```
**PowerShell-Remotesitzung testen**
```powershell
[TEST][SENS] Test-WSMan -ComputerName ""
```
**Befehl remote ausführen**
```powershell
[RO][SENS] Invoke-Command -ComputerName "" -ScriptBlock {
Get-CimInstance Win32_OperatingSystem |
Select-Object Caption, Version, LastBootUpTime
}
```
> Remoteausgaben, Transkripte und Diagnosearchive können sensible Daten enthalten. Sie müssen zweckgebunden gespeichert, geschützt und nach den geltenden Vorgaben gelöscht werden.
30. Gefährliche Schnelllösungen vermeiden
| Maßnahme | Risiko |
|---|---|
| Unbekannten Prozess sofort beenden | Datenverlust oder Dienstausfall |
| Dienst ohne Prüfung neu starten | Unterbrechung abhängiger Anwendungen |
| Windows-Firewall vollständig deaktivieren | Schutzwirkung entfällt |
| Ereignisprotokolle löschen | Diagnosenachweise gehen verloren |
| Registrywerte auf Verdacht ändern | System oder Anwendung wird beschädigt |
| Treiber ungeprüft aktualisieren | Inkompatibilität oder Startfehler |
| Update sofort deinstallieren | Sicherheitslücke oder Folgefehler |
| `chkdsk /f` ungeplant ausführen | Neustart und lange Ausfallzeit |
| DISM oder SFC als Universallösung verwenden | Ursache bleibt ungeklärt |
| Autostart und Dienste wahllos deaktivieren | Sicherheits- und Geschäftsfunktionen fallen aus |
| Speicherabbild unredigiert weitergeben | Geheimnisse und Benutzerdaten werden offengelegt |
| Computer hart ausschalten | Daten- und Dateisystemschäden |
| Systemwiederherstellung ungeprüft starten | Neuere Änderungen können verloren gehen |
| „PC zurücksetzen“ verwenden | Anwendungen, Einstellungen oder Daten gehen verloren |
**Vor einer Änderung prüfen**
1. Ist die Ursache ausreichend eingegrenzt?
2. Welche Systeme und Benutzer sind betroffen?
3. Existiert eine aktuelle Sicherung?
4. Ist die Maßnahme reversibel?
5. Welche Abhängigkeiten bestehen?
6. Ist ein Neustart erforderlich?
7. Gibt es ein Wartungsfenster?
8. Wie wird die Funktion anschließend getestet?
9. Wie wird die Änderung dokumentiert?
31. Sichere Reihenfolge einer Windows-Fehleranalyse
1. Betroffenen Computer und Benutzer eindeutig bestimmen.
2. Originale Fehlermeldung und Fehlerzeitpunkt erfassen.
3. Umfang und Reproduzierbarkeit prüfen.
4. Windows-Version, Build und letzte Startzeit erfassen.
5. Änderungen, Updates und Installationen vor dem Fehler feststellen.
6. Ereignisanzeige und Zuverlässigkeitsverlauf zum Fehlerzeitpunkt prüfen.
7. Prozesse, Dienste und aktuelle Ressourcenbelastung untersuchen.
8. Freien Speicherplatz und Datenträgerzustand kontrollieren.
9. Netzwerk, DNS, Route und benötigte Ports getrennt testen.
10. Benutzerkontext, Berechtigungen und Richtlinien berücksichtigen.
11. Treiber, Geräte und Abhängigkeiten prüfen.
12. Erkenntnisse aus mehreren Datenquellen abgleichen.
13. Sicherung und Rückfallplan kontrollieren.
14. Kleinste geeignete Änderung durchführen.
15. Interne und externe Funktionsprüfung ausführen.
16. Ereignisse und Ressourcen nach der Maßnahme erneut prüfen.
17. Ursache, Maßnahme und Ergebnis dokumentieren.
32. Schnelle Befehlsübersicht
| Aufgabe | Befehl |
|---|---|
| Windows-Version | `[RO] winver` |
| Systeminformationen | `[RO][SENS] systeminfo` |
| Ereignisanzeige | `[RO] eventvwr.msc` |
| Systemereignisse | `[RO][SENS] Get-WinEvent -LogName System -MaxEvents 50` |
| Zuverlässigkeitsverlauf | `[RO] perfmon /rel` |
| Task-Manager | `[RO] taskmgr` |
| Ressourcenmonitor | `[RO] resmon` |
| Leistungsüberwachung | `[RO] perfmon` |
| Prozesse | `[RO][SENS] Get-Process` |
| Dienste | `[RO] Get-Service` |
| Dienstkonfiguration | `[RO] sc.exe qc ""` |
| IP-Konfiguration | `[RO][SENS] ipconfig /all` |
| Adapter | `[RO] Get-NetAdapter` |
| Routingtabelle | `[RO][SENS] route print` |
| Erreichbarkeit | `[TEST] ping ` |
| Route | `[TEST][SENS] tracert ` |
| TCP-Port | `[TEST][SENS] Test-NetConnection "" -Port ` |
| DNS | `[TEST][SENS] Resolve-DnsName ""` |
| TCP-Verbindungen | `[RO][SENS] Get-NetTCPConnection` |
| Ports und PID | `[RO][SENS] netstat -ano` |
| Firewallprofile | `[RO] Get-NetFirewallProfile` |
| Volumes | `[RO] Get-Volume` |
| Datenträger | `[RO] Get-Disk` |
| Geräte | `[RO][SENS] Get-PnpDevice` |
| Treiber | `[RO][SENS] driverquery /v` |
| Geplante Aufgaben | `[RO][SENS] Get-ScheduledTask` |
| Gruppenrichtlinien | `[RO][SENS] gpresult /r` |
| Benutzerkontext | `[RO] whoami` |
| Systemdateien | `[CHANGE][PRIV] sfc /scannow` |
| Abbildprüfung | `[TEST][PRIV] DISM /Online /Cleanup-Image /ScanHealth` |
| Abbildreparatur | `[CHANGE][PRIV] DISM /Online /Cleanup-Image /RestoreHealth` |
33. Dokumentationsvorlage
```text
Ticket:
Datum und Uhrzeit:
Bearbeiter:
Computername:
Windows-Edition:
Windows-Version:
Build:
Architektur:
Letzter Systemstart:
Benutzerkontext:
Domäne oder Arbeitsgruppe:
Originale Fehlermeldung:
Fehlerzeitpunkt:
Erstmals aufgetreten:
Reproduzierbar:
Betroffene Benutzer:
Betroffene Anwendung oder Funktion:
Umfang der Störung:
Letzte funktionierende Nutzung:
Letzte Änderung:
Installierte Updates:
Treiberänderung:
Softwareinstallation:
Richtlinienänderung:
Relevante Ereignisquellen:
Ereignis-IDs:
Zuverlässigkeitsverlauf:
Betroffene Prozesse:
Betroffene Dienste:
CPU:
Arbeitsspeicher:
Datenträger:
Freier Speicher:
IP-Konfiguration:
DNS:
Standardgateway:
Getestetes Ziel:
Getesteter Port:
Testergebnis:
Firewallprofil:
Firewallregel:
Gerätestatus:
Treiberversion:
Systemdateiprüfung:
DISM-Status:
Absturzabbild:
Sensible Daten redigiert:
Vermutete Ursache:
Durchgeführte Tests:
Sicherung geprüft:
Geplante Änderung:
Erwartete Auswirkung:
Rückfallplan:
Neustart erforderlich:
Ergebnis nach der Maßnahme:
Interne Funktionsprüfung:
Externe Funktionsprüfung:
Monitoring:
Weiterführende Maßnahmen:
```
---
**Merksatz**
> Windows stellt viele Diagnosewerkzeuge bereit, doch kein einzelnes Werkzeug liefert automatisch die Ursache. Eine belastbare Fehleranalyse verbindet Zeitpunkt, Ereignisse, Prozesse, Dienste, Ressourcen, Netzwerk, Änderungen und Benutzerkontext zu einem nachvollziehbaren Gesamtbild.
**Quellen und weiterführende Dokumentation**
- [Microsoft Learn – Windows-Problembehandlungsdokumentation](https://learn.microsoft.com/troubleshoot/windows/)
- [Microsoft Learn – Get-WinEvent](https://learn.microsoft.com/powershell/module/microsoft.powershell.diagnostics/get-winevent)
- [Microsoft Learn – Get-Process](https://learn.microsoft.com/powershell/module/microsoft.powershell.management/get-process)
- [Microsoft Learn – Get-Service](https://learn.microsoft.com/powershell/module/microsoft.powershell.management/get-service)
- [Microsoft Learn – Get-Counter](https://learn.microsoft.com/powershell/module/microsoft.powershell.diagnostics/get-counter)
- [Microsoft Learn – Get-NetIPConfiguration](https://learn.microsoft.com/powershell/module/nettcpip/get-netipconfiguration)
- [Microsoft Learn – Test-NetConnection](https://learn.microsoft.com/powershell/module/nettcpip/test-netconnection)
- [Microsoft Learn – Resolve-DnsName](https://learn.microsoft.com/powershell/module/dnsclient/resolve-dnsname)
- [Microsoft Learn – Get-NetTCPConnection](https://learn.microsoft.com/powershell/module/nettcpip/get-nettcpconnection)
- [Microsoft Learn – Get-NetFirewallProfile](https://learn.microsoft.com/powershell/module/netsecurity/get-netfirewallprofile)
- [Microsoft Learn – Get-Volume](https://learn.microsoft.com/powershell/module/storage/get-volume)
- [Microsoft Learn – Get-PnpDevice](https://learn.microsoft.com/powershell/module/pnpdevice/get-pnpdevice)
- [Microsoft Learn – System File Checker](https://learn.microsoft.com/windows-server/administration/windows-commands/sfc)
- [Microsoft Learn – Windows-Abbild mit DISM reparieren](https://learn.microsoft.com/windows-hardware/manufacture/desktop/repair-a-windows-image)
- [Microsoft Learn – Chkdsk](https://learn.microsoft.com/windows-server/administration/windows-commands/chkdsk)
- [Microsoft Learn – GPResult](https://learn.microsoft.com/windows-server/administration/windows-commands/gpresult)
- [Microsoft Learn – Windows-Debuggingwerkzeuge](https://learn.microsoft.com/windows-hardware/drivers/debugger/)