Profi cash: EBICS-Fehler „PKIX path building failed“


Profi cash kann Umsätze der Commerzbank per EBICS nicht abrufen, weil der Java-Kern von Profi cash der neuen GlobalSign-Zertifikatskette des Bankrechners nicht vertraut. Abhilfe ist der Import des Root-Zertifikats „GlobalSign Root R46“ in die Java-Zertifikatslisten von Profi cash, per Skript Repair-ProfiCashTlsTrust.ps1.

Symptom

Der Abruf für das Commerzbank-Konto bricht ab, andere Banken im selben Profi cash funktionieren weiter. Im Job-Protokoll steht:

de.ppi.fis.travic.ebics.kernel.transport.CommunicationException: Bei der Kommunikation
mit https://ebicsveu.commerzbank.com/ebicsweb/ebicsweb: (certificate_unknown) PKIX
path building failed: sun.security.provider.certpath.SunCertPathBuilderException:
unable to find valid certification path to requested target

Nicht verwechseln mit zwei ähnlich aussehenden Fällen:

MeldungBedeutungDieser Artikel?
PKIX path building failedJava-Kern vertraut dem TLS-Zertifikat des Bankrechners nichtJa
EBICS_BANK_PUPKEY_UPDATE_REQUIREDBankschlüssel (E002/X002) wurden gewechselt, Profi cash bietet den Abruf neuer Schlüssel anNein
EBICS_NO_DOWNLOAD_DATA_AVAILABLEVerbindung in Ordnung, es liegen nur keine neuen Daten bereitNein, kein Fehler

Ursache

Der EBICS-Kern von Profi cash (ebics_12.exe, TRAVIC-Kernel) läuft auf einer mitgelieferten Java-Laufzeit. Java prüft TLS-Zertifikate gegen eine eigene Liste (cacerts) und ignoriert den Windows-Zertifikatsspeicher. Deshalb zeigt der Browser das Zertifikat als gültig, während Profi cash es ablehnt.

Die Commerzbank nutzt für ebicsveu.commerzbank.com diese Kette (geprüft am 17.11.2026, Serverzertifikat gültig bis 24.05.2027):

  1. CN=ebicsveu.commerzbank.com, O=COMMERZBANK AG
  2. CN=GlobalSign GCC R46 OV TLS CA 2025 (Zwischenzertifikat, wird vom Server mitgeliefert)
  3. CN=GlobalSign Root R46 (Root, SHA-1 53A2B04BCA6BD645E6398A8EC40DD2BF77C3A290)

Die cacerts-Listen in Profi cash sind keine Java-Standardlisten, sondern vom Hersteller ausgetauscht. Bei der Prüfung enthielten sie GlobalSign R2, R3, R4, R5 und R6, ein Eintrag für R46 war in der Auflistung nicht zu sehen.

Die Listen liegen je Java-Laufzeit unter:

C:\Program Files (x86)\Profi cash\EBICS\bin32\travic-runtime-win86-<Version>\jdk-<Version>-jre\lib\security\cacerts

Auf dem geprüften Rechner gab es drei Laufzeiten nebeneinander (3.0.1, 3.0.31, 3.0.36). Welche davon Profi cash lädt, ist nicht dokumentiert, deshalb werden alle drei Listen behandelt.

Diagnose

Alle Befehle sind für Windows PowerShell 5.1, lesen nur und stehen jeweils in einer Zeile zum Einfügen.

Schritt 1 zeigt, welches Zertifikat am Rechner ankommt. Steht beim Aussteller die Firewall oder eine eigene CA, bricht eine SSL-Interception die Verbindung auf, dann den Host dort ausnehmen:

$t=New-Object Net.Sockets.TcpClient('ebicsveu.commerzbank.com',443);$s=New-Object Net.Security.SslStream($t.GetStream(),$false,{$true});$s.AuthenticateAsClient('ebicsveu.commerzbank.com',$null,'Tls12',$false);$c=New-Object Security.Cryptography.X509Certificates.X509Certificate2($s.RemoteCertificate);$c.Issuer;$c.NotAfter;$t.Close()

Schritt 2 prüft im selben Fenster, ob Windows die Kette als gültig aufbaut. True plus drei Zeilen bis zum Root heißt: Windows ist in Ordnung, der Fehler sitzt in Profi cash:

$ch=New-Object Security.Cryptography.X509Certificates.X509Chain;$ch.Build($c);$ch.ChainStatus.Status;$ch.ChainElements|ForEach-Object{$_.Certificate.Subject}

Schritt 3 sucht die Java-Zertifikatslisten und das Importwerkzeug im Programmordner:

Get-ChildItem 'C:\Program Files (x86)\Profi cash' -Recurse -Include cacerts,keytool.exe -ErrorAction SilentlyContinue | Select-Object FullName,LastWriteTime

Schritt 4 zeigt, was der Bankrechner an Zertifikaten mitschickt. Den Pfad zu keytool.exe aus Schritt 3 übernehmen. Erscheint nur ein Zertifikat, liefert der Server das Zwischenzertifikat nicht mit:

& 'C:\Program Files (x86)\Profi cash\EBICS\bin32\travic-runtime-win86-3.0.36\jdk-17.0.19_10-jre\bin\keytool.exe' -printcert -sslserver ebicsveu.commerzbank.com:443 | Select-String 'Eigent|Aussteller|Owner|Issuer|Certificate #'

Ergebnis der Diagnose am 17.11.2026:

PrüfungErgebnis
SSL-Interception durch Firewall oder ProxyAusgeschlossen, Aussteller ist GlobalSign
Windows-ZertifikatsketteGültig bis GlobalSign Root R46
Vom Server gelieferte KetteVollständig (Serverzertifikat plus Zwischenzertifikat)
BankschlüsselNicht betroffen
Profi-cash-VersionLaut Anwender aktuell, Versionsnummer nicht geprüft

Lösung

Das Skript Repair-ProfiCashTlsTrust.ps1 trägt das Root in alle cacerts-Listen unter dem Profi-cash-Programmordner ein. Es importiert nur ein Root, dem Windows auf dem Rechner bereits vertraut, vergleicht per SHA-256-Fingerabdruck statt per Aliasname und legt vor jeder Änderung eine Sicherung cacerts.bak-<Datum>-<Uhrzeit> an.

  1. Profi cash vollständig schließen. Das Skript bricht ab, solange Profi cash.exe oder ebics_12.exe läuft.
  2. PowerShell als Administrator öffnen und in den Ordner mit dem Skript wechseln.
  3. Probelauf starten, er prüft nur und schreibt nichts.
  4. Echten Lauf mit fest vorgegebenem Fingerabdruck starten.
  5. Profi cash starten und den Abruf für das Commerzbank-Konto wiederholen.
<#
.SYNOPSIS
    Trägt ein fehlendes TLS-Root-Zertifikat in die Java-Zertifikatslisten (cacerts) von Profi cash nach.

.DESCRIPTION
    Hintergrund:
    Der EBICS-Kern von Profi cash läuft auf einer mitgelieferten Java-Laufzeit und prüft
    TLS-Zertifikate der Bankrechner gegen eine eigene Liste (cacerts), NICHT gegen den
    Windows-Zertifikatsspeicher. Wechselt eine Bank auf eine Zertifizierungsstelle, die in
    dieser Liste fehlt, scheitert der Abruf mit:

        PKIX path building failed ... unable to find valid certification path to requested target

    Ablauf des Skripts:
      1. Prüft Adminrechte und ob Profi cash geschlossen ist.
      2. Holt das Serverzertifikat des Bankrechners und lässt Windows die Kette prüfen.
         Nur wenn Windows die Kette als gültig einstuft, wird weitergemacht.
      3. Ermittelt daraus das Root-Zertifikat (oberstes Glied der Kette).
      4. Sucht alle cacerts-Dateien im Profi-cash-Programmordner.
      5. Prüft je Datei per SHA-256-Fingerabdruck, ob das Root schon enthalten ist.
      6. Legt bei Bedarf eine Sicherung an und importiert das Root mit keytool.
      7. Kontrolliert den Import und gibt eine Zusammenfassung aus.

    Sicherheit:
      - Es wird nur ein Root importiert, dem Windows auf diesem Rechner bereits vertraut.
      - Optional kann der erwartete SHA-1-Fingerabdruck fest vorgegeben werden.
      - Vor jeder Änderung entsteht eine Sicherung "cacerts.bak-<Datum>-<Uhrzeit>".

    Rückbau:
      Profi cash schließen und die Sicherungsdatei über die jeweilige "cacerts" zurückkopieren.

    Hinweis:
      Ein Profi-cash-Update kann die Listen überschreiben. Dann das Skript erneut ausführen.

.PARAMETER HostName
    Hostname des EBICS-Bankrechners. Standard: ebicsveu.commerzbank.com

.PARAMETER Port
    TLS-Port des Bankrechners. Standard: 443

.PARAMETER ProfiCashPath
    Programmordner von Profi cash. Ohne Angabe werden die Standardpfade geprüft.

.PARAMETER RootCertFile
    Optional: Root-Zertifikat aus einer Datei (.cer/.crt) verwenden, statt es vom Server
    zu ermitteln. Nötig, wenn der Rechner nur über einen Proxy ins Internet kommt.
    Auch dieses Zertifikat muss von Windows als vertrauenswürdig eingestuft werden.

.PARAMETER ExpectedRootThumbprint
    Optional: Erwarteter SHA-1-Fingerabdruck des Root-Zertifikats. Weicht der ermittelte
    Wert ab, bricht das Skript ohne Änderung ab.
    GlobalSign Root R46: 53A2B04BCA6BD645E6398A8EC40DD2BF77C3A290

.PARAMETER StorePass
    Kennwort der cacerts-Dateien. Java-Standard: changeit

.EXAMPLE
    .\Repair-ProfiCashTlsTrust.ps1 -WhatIf
    Nur prüfen und anzeigen, was geändert würde. Es wird nichts geschrieben.

.EXAMPLE
    .\Repair-ProfiCashTlsTrust.ps1 -ExpectedRootThumbprint 53A2B04BCA6BD645E6398A8EC40DD2BF77C3A290
    Reparatur für die Commerzbank mit fest vorgegebenem Fingerabdruck.

.EXAMPLE
    .\Repair-ProfiCashTlsTrust.ps1 -HostName ebics.andere-bank.de
    Gleiche Reparatur für einen anderen Bankrechner.

.NOTES
    Getestet für: Windows PowerShell 5.1
    Aufruf:       In einer als Administrator gestarteten PowerShell
    Exitcodes:    0 = in Ordnung (importiert oder bereits vorhanden), 1 = Fehler/Abbruch
#>

[CmdletBinding(SupportsShouldProcess = $true)]
param(
    [string]$HostName = 'ebicsveu.commerzbank.com',

    [ValidateRange(1, 65535)]
    [int]$Port = 443,

    [string]$ProfiCashPath,

    [string]$RootCertFile,

    [string]$ExpectedRootThumbprint,

    [string]$StorePass = 'changeit'
)

Set-StrictMode -Version 2.0
$ErrorActionPreference = 'Stop'

# ---------------------------------------------------------------------------
# Hilfsfunktionen
# ---------------------------------------------------------------------------

function Write-Step {
    <# Gibt eine einheitlich formatierte Statuszeile aus. #>
    param(
        [string]$Message,
        [ValidateSet('Info', 'Ok', 'Warn', 'Error')]
        [string]$Level = 'Info'
    )

    $prefix = '[ .. ]'
    $color  = 'Gray'
    switch ($Level) {
        'Ok'    { $prefix = '[ OK ]'; $color = 'Green' }
        'Warn'  { $prefix = '[WARN]'; $color = 'Yellow' }
        'Error' { $prefix = '[FEHL]'; $color = 'Red' }
    }
    Write-Host ("{0} {1}" -f $prefix, $Message) -ForegroundColor $color
}

function Test-IsAdministrator {
    <# Prüft, ob die aktuelle PowerShell mit Administratorrechten läuft. #>
    $identity  = [Security.Principal.WindowsIdentity]::GetCurrent()
    $principal = New-Object Security.Principal.WindowsPrincipal($identity)
    return $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
}

function Get-Sha256Fingerprint {
    <#
        Liefert den SHA-256-Fingerabdruck eines Zertifikats im keytool-Format
        (Großbuchstaben, durch Doppelpunkte getrennt), z. B. "4F:A3:12:...".
    #>
    param([Security.Cryptography.X509Certificates.X509Certificate2]$Certificate)

    $sha = [Security.Cryptography.SHA256]::Create()
    try {
        $hash = $sha.ComputeHash($Certificate.RawData)
    }
    finally {
        $sha.Dispose()
    }
    return ([BitConverter]::ToString($hash)).Replace('-', ':')
}

function Invoke-Keytool {
    <#
        Ruft keytool auf und liefert Exitcode und Ausgabe zurück.
        keytool schreibt Warnungen auf stderr. In PowerShell 5.1 würden diese bei
        $ErrorActionPreference = 'Stop' das Skript abbrechen, deshalb wird die
        Einstellung für den Aufruf lokal auf 'Continue' gesetzt.
    #>
    param(
        [string]$KeytoolPath,
        [string[]]$Arguments
    )

    $ErrorActionPreference = 'Continue'
    $output = & $KeytoolPath @Arguments 2>&1 | ForEach-Object { "$_" }
    $code   = $LASTEXITCODE

    return New-Object PSObject -Property @{
        ExitCode = $code
        Output   = @($output)
    }
}

function Get-ServerCertificate {
    <#
        Baut eine TLS-Verbindung zum Bankrechner auf und liefert dessen Serverzertifikat.
        Es wird die Standardprüfung von Windows verwendet (Kette, Gültigkeit, Hostname).
        Schlägt diese fehl, wirft AuthenticateAsClient einen Fehler und das Skript bricht ab.
    #>
    param(
        [string]$TargetHost,
        [int]$TargetPort
    )

    $client = New-Object Net.Sockets.TcpClient
    try {
        $client.Connect($TargetHost, $TargetPort)
        $ssl = New-Object Net.Security.SslStream($client.GetStream(), $false)
        try {
            $ssl.AuthenticateAsClient($TargetHost, $null, [Security.Authentication.SslProtocols]::Tls12, $false)
            return New-Object Security.Cryptography.X509Certificates.X509Certificate2($ssl.RemoteCertificate)
        }
        finally {
            $ssl.Dispose()
        }
    }
    finally {
        $client.Close()
    }
}

function Get-TrustedRoot {
    <#
        Lässt Windows die Zertifikatskette aufbauen und liefert das Root-Zertifikat.
        Bricht ab, wenn Windows die Kette nicht als gültig einstuft.
    #>
    param([Security.Cryptography.X509Certificates.X509Certificate2]$Certificate)

    $chain = New-Object Security.Cryptography.X509Certificates.X509Chain
    if (-not $chain.Build($Certificate)) {
        $status = ($chain.ChainStatus | ForEach-Object { $_.Status }) -join ', '
        throw "Windows stuft die Zertifikatskette nicht als gültig ein ($status). Es wird nichts importiert."
    }

    # Oberstes Glied der Kette ist das Root. Kopie anlegen, da die Kette danach freigegeben wird.
    $last = $chain.ChainElements[$chain.ChainElements.Count - 1].Certificate
    $root = New-Object Security.Cryptography.X509Certificates.X509Certificate2(, $last.RawData)

    # Ein echtes Root ist selbstsigniert: Inhaber und Aussteller sind identisch.
    if ($root.Subject -ne $root.Issuer) {
        throw "Das oberste Zertifikat der Kette ist nicht selbstsigniert ($($root.Subject)). Abbruch."
    }
    return $root
}

function Get-AliasForCertificate {
    <#
        Leitet aus dem CN des Zertifikats einen keytool-Alias ab, z. B.
        "CN=GlobalSign Root R46, ..." -> "globalsignrootr46".
        Ist der Alias in der Liste schon mit einem ANDEREN Zertifikat belegt,
        wird ein Datumsanhang ergänzt, damit nichts überschrieben wird.
    #>
    param(
        [Security.Cryptography.X509Certificates.X509Certificate2]$Certificate,
        [string]$KeytoolPath,
        [string]$KeystorePath,
        [string]$Password
    )

    $cn = $Certificate.GetNameInfo([Security.Cryptography.X509Certificates.X509NameType]::SimpleName, $false)
    $alias = ($cn -replace '[^A-Za-z0-9]', '').ToLowerInvariant()
    if ([string]::IsNullOrEmpty($alias)) {
        $alias = 'importedroot'
    }

    $check = Invoke-Keytool -KeytoolPath $KeytoolPath -Arguments @('-list', '-alias', $alias, '-keystore', $KeystorePath, '-storepass', $Password)
    if ($check.ExitCode -eq 0) {
        $alias = '{0}-{1}' -f $alias, (Get-Date -Format 'yyyyMMdd')
    }
    return $alias
}

# ---------------------------------------------------------------------------
# Hauptablauf
# ---------------------------------------------------------------------------

$exitCode = 0
$tempCert = $null

try {
    Write-Host ''
    Write-Host 'Profi cash: TLS-Root-Zertifikat in die Java-Zertifikatslisten nachtragen' -ForegroundColor Cyan
    Write-Host ''

    # --- 1. Voraussetzungen -------------------------------------------------

    if (-not (Test-IsAdministrator)) {
        throw 'Das Skript benötigt Administratorrechte. PowerShell bitte "Als Administrator ausführen".'
    }

    # Laufende Profi-cash-Prozesse würden die geänderte Liste erst nach Neustart laden.
    # Es wird bewusst nichts automatisch beendet, um keine offenen Aufträge zu verlieren.
    $running = @(Get-Process -ErrorAction SilentlyContinue | Where-Object { $_.ProcessName -like 'Profi cash*' -or $_.ProcessName -like 'ebics_*' })
    if ($running.Count -gt 0) {
        $names = ($running | ForEach-Object { $_.ProcessName } | Sort-Object -Unique) -join ', '
        throw "Profi cash läuft noch ($names). Bitte Profi cash vollständig schließen und das Skript erneut starten."
    }

    # Programmordner ermitteln: Parameter hat Vorrang, sonst Standardpfade.
    if ([string]::IsNullOrEmpty($ProfiCashPath)) {
        $candidates = @()
        if (${env:ProgramFiles(x86)}) { $candidates += (Join-Path ${env:ProgramFiles(x86)} 'Profi cash') }
        if ($env:ProgramFiles)        { $candidates += (Join-Path $env:ProgramFiles 'Profi cash') }
        $ProfiCashPath = $candidates | Where-Object { Test-Path -LiteralPath $_ } | Select-Object -First 1
    }
    if ([string]::IsNullOrEmpty($ProfiCashPath) -or -not (Test-Path -LiteralPath $ProfiCashPath)) {
        throw 'Programmordner von Profi cash nicht gefunden. Bitte mit -ProfiCashPath angeben.'
    }
    Write-Step "Programmordner: $ProfiCashPath" 'Ok'

    # --- 2. Root-Zertifikat ermitteln --------------------------------------

    if (-not [string]::IsNullOrEmpty($RootCertFile)) {
        # Variante A: Zertifikat aus Datei (z. B. bei Proxy-Umgebungen).
        if (-not (Test-Path -LiteralPath $RootCertFile)) {
            throw "Zertifikatsdatei nicht gefunden: $RootCertFile"
        }
        $fileCert = New-Object Security.Cryptography.X509Certificates.X509Certificate2((Resolve-Path -LiteralPath $RootCertFile).Path)
        $root = Get-TrustedRoot -Certificate $fileCert
        Write-Step "Root aus Datei gelesen und von Windows als vertrauenswürdig bestätigt." 'Ok'
    }
    else {
        # Variante B: Zertifikat direkt vom Bankrechner holen.
        Write-Step "Verbinde mit ${HostName}:${Port} ..."
        $serverCert = Get-ServerCertificate -TargetHost $HostName -TargetPort $Port
        Write-Step "Serverzertifikat: $($serverCert.Subject)" 'Ok'
        Write-Step "Aussteller:       $($serverCert.Issuer)"
        $root = Get-TrustedRoot -Certificate $serverCert
        Write-Step 'Windows hat die Zertifikatskette als gültig bestätigt.' 'Ok'
    }

    $rootSha256 = Get-Sha256Fingerprint -Certificate $root
    Write-Step "Root-Zertifikat:  $($root.Subject)" 'Ok'
    Write-Step "SHA-1:            $($root.Thumbprint)"
    Write-Step "SHA-256:          $rootSha256"
    Write-Step "Gültig bis:       $($root.NotAfter.ToString('dd.MM.yyyy'))"

    # Optionaler Abgleich mit einem fest vorgegebenen Fingerabdruck.
    if (-not [string]::IsNullOrEmpty($ExpectedRootThumbprint)) {
        $expected = ($ExpectedRootThumbprint -replace '[^0-9A-Fa-f]', '').ToUpperInvariant()
        if ($expected -ne $root.Thumbprint.ToUpperInvariant()) {
            throw "Fingerabdruck weicht ab. Erwartet: $expected, ermittelt: $($root.Thumbprint). Es wird nichts importiert."
        }
        Write-Step 'Fingerabdruck stimmt mit der Vorgabe überein.' 'Ok'
    }

    # --- 3. Zertifikatslisten suchen ---------------------------------------

    $keystores = @(Get-ChildItem -LiteralPath $ProfiCashPath -Recurse -Filter 'cacerts' -File -ErrorAction SilentlyContinue)
    if ($keystores.Count -eq 0) {
        throw "Keine cacerts-Dateien unter $ProfiCashPath gefunden."
    }
    Write-Step "$($keystores.Count) Zertifikatsliste(n) gefunden." 'Ok'

    # Ersatz-keytool, falls neben einer Liste keines liegt.
    $fallbackKeytool = Get-ChildItem -LiteralPath $ProfiCashPath -Recurse -Filter 'keytool.exe' -File -ErrorAction SilentlyContinue |
        Sort-Object LastWriteTime -Descending | Select-Object -First 1

    # Root für keytool als temporäre Datei ablegen.
    $tempCert = Join-Path $env:TEMP ("proficash-root-{0}.cer" -f ([Guid]::NewGuid().ToString('N')))
    [IO.File]::WriteAllBytes($tempCert, $root.RawData)

    # --- 4. Je Liste prüfen und bei Bedarf importieren ---------------------

    $results = @()

    foreach ($keystore in $keystores) {
        Write-Host ''
        Write-Step "Liste: $($keystore.FullName)"

        # keytool der zugehörigen Java-Laufzeit: <jre>\lib\security\cacerts -> <jre>\bin\keytool.exe
        $jreRoot = Split-Path (Split-Path $keystore.DirectoryName -Parent) -Parent
        $keytool = Join-Path $jreRoot 'bin\keytool.exe'
        if (-not (Test-Path -LiteralPath $keytool)) {
            if ($null -eq $fallbackKeytool) {
                Write-Step 'Kein keytool.exe gefunden, Liste wird übersprungen.' 'Error'
                $results += New-Object PSObject -Property @{ Keystore = $keystore.FullName; Result = 'Fehler: keytool fehlt' }
                $exitCode = 1
                continue
            }
            $keytool = $fallbackKeytool.FullName
        }

        # Bestand lesen. Verglichen wird der SHA-256-Fingerabdruck, nicht der Aliasname,
        # weil Aliasnamen frei vergeben und damit nicht aussagekräftig sind.
        $list = Invoke-Keytool -KeytoolPath $keytool -Arguments @('-list', '-keystore', $keystore.FullName, '-storepass', $StorePass)
        if ($list.ExitCode -ne 0) {
            Write-Step 'Liste konnte nicht gelesen werden (falsches Kennwort oder defekte Datei).' 'Error'
            $results += New-Object PSObject -Property @{ Keystore = $keystore.FullName; Result = 'Fehler: nicht lesbar' }
            $exitCode = 1
            continue
        }

        if (($list.Output -join "`n").ToUpperInvariant().Contains($rootSha256)) {
            Write-Step 'Root ist bereits enthalten, keine Änderung nötig.' 'Ok'
            $results += New-Object PSObject -Property @{ Keystore = $keystore.FullName; Result = 'Bereits vorhanden' }
            continue
        }

        Write-Step 'Root fehlt in dieser Liste.' 'Warn'

        if (-not $PSCmdlet.ShouldProcess($keystore.FullName, "Sicherung anlegen und Root '$($root.Subject)' importieren")) {
            $results += New-Object PSObject -Property @{ Keystore = $keystore.FullName; Result = 'Fehlt (nur geprüft)' }
            continue
        }

        # Sicherung mit Zeitstempel, damit frühere Sicherungen nicht überschrieben werden.
        $backup = '{0}.bak-{1}' -f $keystore.FullName, (Get-Date -Format 'yyyyMMdd-HHmmss')
        Copy-Item -LiteralPath $keystore.FullName -Destination $backup
        Write-Step "Sicherung: $backup" 'Ok'

        $alias = Get-AliasForCertificate -Certificate $root -KeytoolPath $keytool -KeystorePath $keystore.FullName -Password $StorePass

        $import = Invoke-Keytool -KeytoolPath $keytool -Arguments @(
            '-importcert', '-noprompt', '-trustcacerts',
            '-alias', $alias,
            '-file', $tempCert,
            '-keystore', $keystore.FullName,
            '-storepass', $StorePass
        )

        # Kontrolle: Der Fingerabdruck muss jetzt in der Liste stehen.
        $verify = Invoke-Keytool -KeytoolPath $keytool -Arguments @('-list', '-keystore', $keystore.FullName, '-storepass', $StorePass)
        $present = ($verify.ExitCode -eq 0) -and (($verify.Output -join "`n").ToUpperInvariant().Contains($rootSha256))

        if ($import.ExitCode -eq 0 -and $present) {
            Write-Step "Root importiert (Alias: $alias)." 'Ok'
            $results += New-Object PSObject -Property @{ Keystore = $keystore.FullName; Result = "Importiert ($alias)" }
        }
        else {
            Write-Step 'Import fehlgeschlagen. Ausgabe von keytool:' 'Error'
            $import.Output | ForEach-Object { Write-Host "       $_" -ForegroundColor Red }
            $results += New-Object PSObject -Property @{ Keystore = $keystore.FullName; Result = 'Fehler: Import' }
            $exitCode = 1
        }
    }

    # --- 5. Zusammenfassung -------------------------------------------------

    Write-Host ''
    Write-Host 'Zusammenfassung' -ForegroundColor Cyan
    $results | Select-Object Result, Keystore | Format-Table -AutoSize -Wrap | Out-Host

    if ($exitCode -eq 0) {
        Write-Step 'Fertig. Profi cash starten und den Abruf für das betroffene Konto wiederholen.' 'Ok'
    }
    else {
        Write-Step 'Mindestens eine Liste konnte nicht bearbeitet werden, siehe oben.' 'Error'
    }
}
catch {
    Write-Host ''
    Write-Step $_.Exception.Message 'Error'
    $exitCode = 1
}
finally {
    # Temporäre Zertifikatsdatei wieder entfernen.
    if ($null -ne $tempCert -and (Test-Path -LiteralPath $tempCert)) {
        Remove-Item -LiteralPath $tempCert -Force -ErrorAction SilentlyContinue
    }
}

exit $exitCode


Probelauf:

powershell.exe -ExecutionPolicy Bypass -File .\Repair-ProfiCashTlsTrust.ps1 -WhatIf


Echter Lauf:

powershell.exe -ExecutionPolicy Bypass -File .\Repair-ProfiCashTlsTrust.ps1 -ExpectedRootThumbprint 53A2B04BCA6BD645E6398A8EC40DD2BF77C3A290


Parameter des Skripts:

ParameterZweckStandard
-HostNameHostname des EBICS-Bankrechners, auch für andere Banken nutzbarebicsveu.commerzbank.com
-PortTLS-Port443
-ProfiCashPathProgrammordner, falls abweichend installiertStandardpfade unter Program Files
-RootCertFileRoot aus einer .cer-Datei statt vom Server, nötig hinter einem Proxyleer
-ExpectedRootThumbprintErwarteter SHA-1-Fingerabdruck, bei Abweichung Abbruch ohne Änderungleer
-StorePassKennwort der cacerts-Dateienchangeit
-WhatIfNur prüfen, nichts schreibenaus

Die Zusammenfassung am Ende nennt je Liste eines von drei Ergebnissen: „Bereits vorhanden“, „Importiert“ oder „Fehler“. Exitcode 0 heißt in Ordnung, 1 heißt Fehler oder Abbruch.