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:
| Meldung | Bedeutung | Dieser Artikel? |
|---|---|---|
PKIX path building failed | Java-Kern vertraut dem TLS-Zertifikat des Bankrechners nicht | Ja |
EBICS_BANK_PUPKEY_UPDATE_REQUIRED | Bankschlüssel (E002/X002) wurden gewechselt, Profi cash bietet den Abruf neuer Schlüssel an | Nein |
EBICS_NO_DOWNLOAD_DATA_AVAILABLE | Verbindung in Ordnung, es liegen nur keine neuen Daten bereit | Nein, 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):
CN=ebicsveu.commerzbank.com, O=COMMERZBANK AGCN=GlobalSign GCC R46 OV TLS CA 2025(Zwischenzertifikat, wird vom Server mitgeliefert)CN=GlobalSign Root R46(Root, SHA-153A2B04BCA6BD645E6398A8EC40DD2BF77C3A290)
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üfung | Ergebnis |
|---|---|
| SSL-Interception durch Firewall oder Proxy | Ausgeschlossen, Aussteller ist GlobalSign |
| Windows-Zertifikatskette | Gültig bis GlobalSign Root R46 |
| Vom Server gelieferte Kette | Vollständig (Serverzertifikat plus Zwischenzertifikat) |
| Bankschlüssel | Nicht betroffen |
| Profi-cash-Version | Laut 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.
- Profi cash vollständig schließen. Das Skript bricht ab, solange
Profi cash.exeoderebics_12.exeläuft. - PowerShell als Administrator öffnen und in den Ordner mit dem Skript wechseln.
- Probelauf starten, er prüft nur und schreibt nichts.
- Echten Lauf mit fest vorgegebenem Fingerabdruck starten.
- 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:
| Parameter | Zweck | Standard |
|---|---|---|
-HostName | Hostname des EBICS-Bankrechners, auch für andere Banken nutzbar | ebicsveu.commerzbank.com |
-Port | TLS-Port | 443 |
-ProfiCashPath | Programmordner, falls abweichend installiert | Standardpfade unter Program Files |
-RootCertFile | Root aus einer .cer-Datei statt vom Server, nötig hinter einem Proxy | leer |
-ExpectedRootThumbprint | Erwarteter SHA-1-Fingerabdruck, bei Abweichung Abbruch ohne Änderung | leer |
-StorePass | Kennwort der cacerts-Dateien | changeit |
-WhatIf | Nur prüfen, nichts schreiben | aus |
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.