Kategorie: Windows 10

Die Verwaltung von Passwörtern ist in der modernen IT-Landschaft ein zentrales Thema. In diesem Artikel gehe ich darauf ein, wie man mithilfe von PowerShell und KeePass-Passwortdatenbanken einen sicheren Zugriff auf sensible Informationen ermöglicht. Dabei werden zwei Ansätze vorgestellt: Ein klassisches Skript, das direkt die KeePassLib.dll verwendet, sowie eine Methode, die das PowerShell-Modul Microsoft.PowerShell.SecretManagement in Kombination mit einem KeePass-Vault-Adapter nutzt. Außerdem zeige ich, wie man das Masterkennwort schützt, sodass es nicht als Klartext im Skript sichtbar ist.

1. Das klassische PowerShell-Skript mit KeePassLib.dll

Ein häufiger Ansatz besteht darin, ein PowerShell-Skript zu erstellen, das direkt auf die KeePassLib.dll zugreift. Diese Bibliothek, die üblicherweise bei der Installation von KeePass verfügbar ist, stellt alle nötigen Klassen und Methoden bereit, um auf die Datenbank zuzugreifen und Einträge auszulesen.

Beispielskript:

<#
Dieses Skript öffnet eine KeePass-Datenbank (.kdbx) und extrahiert das Passwort eines
spezifizierten Eintrags. Bitte passe anschließend Pfade, den Eintragstitel und das Masterkennwort 
an deine Gegebenheiten an.

Voraussetzungen:
- KeePassLib.dll (normalerweise über die KeePass-Installation enthalten)
- Eine funktionierende KeePass-Datenbank (.kdbx) und das zugehörige Masterkennwort

Achtung: Sensible Daten (wie Masterkennwort) sollten nicht im Klartext hinterlegt werden.
#>

# Pfad zur KeePassLib.dll (anpassen, falls erforderlich)
$libPath = "C:\Program Files (x86)\KeePass Password Safe 2\KeePassLib.dll"
if (-Not (Test-Path $libPath)) {
    Write-Error "Die KeePassLib.dll wurde unter '$libPath' nicht gefunden."
    exit 1
}
Add-Type -Path $libPath

# Datenbankpfad und Zugangsdaten (bitte an deine Umgebung anpassen)
$dbPath = "C:\Path\Zu\Deiner\Datenbank.kdbx"   # Pfad zur KeePass-Datenbank
$masterPassword = "DeinMasterPasswort"          # Masterkennwort (nicht im Klartext speichern!)

# Erstelle einen CompositeKey und füge das Masterkennwort als Benutzer-Schlüssel hinzu
$compositeKey = New-Object KeePassLib.Keys.CompositeKey
$passwordKey = New-Object KeePassLib.Keys.KcpPassword
$passwordKey.Password = $masterPassword
$compositeKey.AddUserKey($passwordKey)

# Öffne und lade die KeePass-Datenbank
$db = New-Object KeePassLib.PwDatabase
try {
    $db.Open($dbPath, $compositeKey, [System.IO.FileAccess]::Read)
} catch {
    Write-Error "Fehler beim Öffnen der Datenbank: $_"
    exit 1
}

# Suche nach einem Eintrag anhand seines Titels (ein Beispielwert, bitte anpassen)
$entryTitle = "MeinEintrag"   # Titel des gewünschten Eintrags
$entry = $db.RootGroup.FindEntries({$_.Strings.ReadSafe("Title") -eq $entryTitle}, $true) | Select-Object -First 1

if ($null -eq $entry) {
    Write-Output "Kein Eintrag mit dem Titel '$entryTitle' gefunden."
} else {
    # Extrahiere das Passwort des gefundenen Eintrags
    $password = $entry.Strings.ReadSafe("Password")
    Write-Output "Das Passwort für den Eintrag '$entryTitle' lautet: $password"

    # Hier kannst du das Passwort weiterverarbeiten, z. B. einem anderen Skript übergeben oder in Variablen speichern.
}

# Schließe die Datenbank, um Ressourcen freizugeben
$db.Close()

Erklärung:

• Das Skript lädt zunächst die KeePassLib.dll und überprüft, ob der Pfad korrekt ist.
• Anschließend wird ein CompositeKey erstellt, dem das Masterkennwort als Schlüssel hinzugefügt wird.
• Mithilfe der gewählten API öffnet man die KeePass-Datenbank im Lesemodus und sucht nach einem Eintrag anhand des Titels.
• Wird der Eintrag gefunden, wird das Passwort extrahiert und ausgegeben, sodass es in weiteren Prozessen genutzt werden kann.

Dieser Ansatz bietet eine direkte und flexible Möglichkeit, mit KeePass-Datenbanken zu arbeiten, setzt aber voraus, dass sensible Daten (etwa das Masterkennwort) sicher gehandhabt werden.

2. Nutzung von Microsoft.PowerShell.SecretManagement

Ein moderner und oft sichererer Ansatz ist die Verwendung des Moduls Microsoft.PowerShell.SecretManagement. Dieser Vault-Ansatz bietet eine einheitliche API zur Verwaltung von Geheimnissen aus verschiedensten Quellen – KeePass gehört dabei mit einem dedizierten Adapter dazu.

Der erste Schritt besteht darin, die Module zu installieren:

Install-Module Microsoft.PowerShell.SecretManagement -Scope CurrentUser
Install-Module KeePassSecretManagement -Scope CurrentUser

Nach erfolgreicher Installation registrierst du deinen KeePass-Vault in der SecretManagement-Umgebung:

Register-SecretVault -Name "KeePassVault" -ModuleName KeePassSecretManagement -DefaultVault `
    -VaultParameters @{ 
        DatabasePath = "C:\Path\Zu\Deiner\Datenbank.kdbx"; 
        MasterPassword = "DeinMasterPasswort" 
    }

Sobald der Vault registriert ist, kannst du über den Befehl Get-Secret darauf zugreifen:

Get-Secret -Name "MeinEintrag" -Vault "KeePassVault"

Vorteile:

• Einheitliche Schnittstelle: Egal, ob du Azure Key Vault, SecretStore oder KeePass einsetzt – die API bleibt gleich.
• Verbesserte Sicherheit: Der Vault-Adapter abstrahiert die direkte Handhabung von Kennwörtern und ermöglicht damit einen saubereren Zugang.
• Flexibilität und Erweiterbarkeit: Weitere Vaults können problemlos integriert werden, was besonders in größeren Automatisierungsszenarien nützlich ist.

3. Schutz des Masterkennworts – So vermeidest du Klartext im Skript

Ein häufiges Sicherheitsrisiko bei Skripten ist die Hardcodierung von Passwörtern. Es gibt einige Best Practices, um das Masterkennwort zu schützen:

3.1. Eingabeaufforderung zur Laufzeit mit SecureString

Statt das Kennwort im Skript zu speichern, forderst du den Benutzer zur Laufzeit zur Eingabe auf. Dies erfolgt mit dem Parameter -AsSecureString:

$secureMasterPassword = Read-Host "Bitte gib dein Masterkennwort ein" -AsSecureString

Falls ein normaler String benötigt wird, kann der SecureString konvertiert werden:

$unsecureMasterPassword = [Runtime.InteropServices.Marshal]::PtrToStringAuto(
    [Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureMasterPassword)
)

3.2. Nutzung von SecretManagement/SecretStore

Neben der direkten Eingabe kannst du das Kennwort auch zentral über ein Vault-Modul speichern. So greifst du später sicher darauf zu, ohne es im Skript zu hinterlegen:

Register-SecretVault -Name "KeePassVault" -ModuleName KeePassSecretManagement -DefaultVault `
    -VaultParameters @{ 
        DatabasePath   = "C:\Path\Zu\Deiner\Datenbank.kdbx"; 
        MasterPassword = (Get-Secret -Name "MasterKennwort" -Vault "SecretStore")
    }

3.3. Verschlüsselte Konfigurationsdatei

Eine weitere Möglichkeit ist, das Masterkennwort in einer verschlüsselten Datei abzulegen. Dabei wird der SecureString mit ConvertFrom-SecureString verschlüsselt abgespeichert und bei Bedarf wieder eingelesen:

Speichern:

$secureMasterPassword = Read-Host "Bitte gib dein Masterkennwort ein" -AsSecureString
$secureMasterPassword | ConvertFrom-SecureString | Out-File "C:\Path\zur\secret.config"

Laden:

$encryptedString = Get-Content "C:\Path\zur\secret.config"
$secureMasterPassword = $encryptedString | ConvertTo-SecureString

Diese Methode nutzt die Windows-Datenschutz-API (DPAPI), die sicherstellt, dass die Datei nur mit dem Benutzerkonto, das sie erstellt hat, entschlüsselt werden kann.

Fazit

Die sichere Verwaltung von Passwörtern ist in jeder IT-Umgebung essenziell. Mit PowerShell und KeePass stehen dir zwei leistungsfähige Ansätze zur Verfügung:

• Der direkte Zugriff über die KeePassLib.dll bietet Flexibilität und Kontrolle, erfordert aber sorgfältigen Umgang mit sensiblen Daten.
• Die Verwendung des Microsoft.PowerShell.SecretManagement-Moduls in Kombination mit einem KeePass-Vault-Adapter sorgt für eine einheitliche, moderne und oft sicherere Verwaltung von Geheimnissen.

Besonders wichtig ist es, das Masterkennwort nicht im Klartext im Skript zu hinterlegen, sondern es entweder zur Laufzeit einzugeben, zentral in einem sicheren Vault zu speichern oder in einer verschlüsselten Datei abzulegen. Dadurch minimierst du das Risiko eines unbefugten Zugriffs und stellst sicher, dass deine Passwörter geschützt bleiben.

In der heutigen digitalen Welt ist die Sicherheit von Passwörtern wichtiger denn je. Datenlecks und Passwortdiebstähle sind an der Tagesordnung, und Millionen von Zugangsdaten gelangen regelmäßig in die Hände von Cyberkriminellen. Ein äußerst nützliches Tool zur Überprüfung der Sicherheit von Passwörtern ist die API „api.pwnedpasswords.com“, die von Have I Been Pwned (HIBP) bereitgestellt wird.

Wie funktioniert die API?

Die API verwendet das k-Anonymitätsprinzip, um sicherzustellen, dass das zu prüfende Passwort nicht vollständig offengelegt wird. Der Prozess sieht folgendermaßen aus:

1. Der Benutzer oder die Anwendung hashen das zu überprüfende Passwort mit SHA-1.
2. Die ersten 5 Zeichen des Hashs werden an die API gesendet.
3. Die API antwortet mit einer Liste aller Hashes, die mit diesen ersten 5 Zeichen beginnen und in ihrer Datenbank gefunden wurden.
4. Die Anwendung vergleicht den vollständigen Hash des geprüften Passworts mit den zurückgegebenen Hashes.
5. Falls eine Übereinstimmung gefunden wird, bedeutet dies, dass das Passwort kompromittiert ist und nicht verwendet werden sollte.

Dieses Verfahren stellt sicher, dass ein vollständiger Passwort-Hash niemals über das Internet übertragen wird, wodurch das Risiko minimiert wird, dass Angreifer sensible Informationen abfangen können.

Wie spreche ich die API per Powershell auf?

Ich habe den Abruf in eine Funktion geschrieben. Dieses hat für mich den Vorteil, dass ich den dann notwendigen Aufruf an mehrern Stellen in Programmierungen verwendne kann.

function Test-PwnedPassword {
    param (
        [string]$Password
    )

    # Passwort hashen (SHA-1)
    $sha1 = New-Object System.Security.Cryptography.SHA1Managed
    $hashBytes = $sha1.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($Password))
    $hashString = [BitConverter]::ToString($hashBytes) -replace '-',''
    
    # Ersten fünf Zeichen extrahieren
    $prefix = $hashString.Substring(0, 5)
    
    # API-Abfrage
    $url = "https://api.pwnedpasswords.com/range/$prefix"
    try {
        $response = Invoke-WebRequest -Uri $url -UseBasicParsing
        $hashes = $response.Content -split "`n"

        # Prüfen, ob das vollständige Hash-Suffix in der Liste ist
        foreach ($line in $hashes) {
            $parts = $line -split ":"
            if ($hashString.Substring(5) -eq $parts[0]) {
                Write-Output "Das Passwort wurde bereits $($parts[1]) Mal gefunden!"
                return
            }
        }
        Write-Output "Das Passwort wurde nicht gefunden."
    }
    catch {
        Write-Output "Fehler bei der API-Anfrage: $_"
    }
}

Für den Test des Skriptes kann folgender Test-Aufruf verwendet werden.

$passwort = Read-Host „Geben Sie Ihr Passwort ein“
Test-PwnedPassword -Password $passwort