Everyone knows SAP, everyone uses SAP, everyone uses RFC, no one knows RFC: From RFC to RCE 16 years later

Fabian Hagg (Technical Security Consultant and Head of Security for SAP Services · SEC Consult)

TROOPERS23 · Day 2 · Attack & Research · Attack & Research

Overview

Fabian Hagg's talk at TROOPERS 2023, "Everyone knows SAP, everyone uses SAP, everyone uses RFC, no one knows RFC: From RFC to RCE 16 years later," delves into critical security vulnerabilities within the Remote Function Call (RFC) interface of the SAP ABAP application server. This presentation marks a significant contribution to SAP security research, revisiting an interface first targeted by practical attacks 16 years prior and uncovering a chain of design flaws and implementation bugs that culminate in unauthenticated Remote Code Execution (RCE). The research highlights the enduring complexity and often overlooked attack surface within widely deployed enterprise software.

Watch on YouTube · Slides

Visual summary for Everyone knows SAP, everyone uses SAP, everyone uses RFC, no one knows RFC: From RFC to RCE 16 years later by Fabian Hagg
Visual summary for Everyone knows SAP, everyone uses SAP, everyone uses RFC, no one knows RFC: From RFC to RCE 16 years later by Fabian Hagg

Key moments

  1. 0:00 Introduction and motivation for RFC vulnerability research
  2. 13:50 Discovery of passwordless logon via HMAC tickets
  3. 27:00 Demo: Bypassing authentication with leaked tickets
  4. 29:50 Fuzzing reveals unauthenticated out-of-bounds write
  5. 37:00 Full exploit chain: Unauthenticated remote code execution
  6. 44:00 Patching challenges and defense recommendations
  7. 50:50 Q&A: Patch details and Wireshark dissector

Everyone knows SAP, everyone uses SAP, everyone uses RFC, no one knows RFC: From RFC to RCE 16 years later

Speakers: Fabian Hagg, Technical Security Consultant and Head of Security for SAP Services, SEC Consult

Conference: TROOPERS

YouTube: https://www.youtube.com/watch?v=gt_RdzZuq_s

Overview

Fabian Hagg's talk at TROOPERS 2023, "Everyone knows SAP, everyone uses SAP, everyone uses RFC, no one knows RFC: From RFC to RCE 16 years later," delves into critical security vulnerabilities within the Remote Function Call (RFC) interface of the SAP ABAP application server. This presentation marks a significant contribution to SAP security research, revisiting an interface first targeted by practical attacks 16 years prior and uncovering a chain of design flaws and implementation bugs that culminate in unauthenticated Remote Code Execution (RCE). The research highlights the enduring complexity and often overlooked attack surface within widely deployed enterprise software.

Fabian Hagg, a Technical Security Consultant and Head of Security for SAP Services at SEC Consult, presented his findings from an in-depth analysis of the RFC Type 3 implementation. His work not only dissects the intricate, often undocumented, RFC protocol but also demonstrates how seemingly minor weaknesses can be chained together to achieve maximum impact. This talk is particularly relevant given SAP's pervasive use across 400,000 organizations globally for their most business-critical systems, underscoring the severe implications of such vulnerabilities.

The core motivation for this research stemmed from an observed authorization bypass during a previous project, which led Hagg to investigate the server-side implementation of RFC Type 3. This specific communication type is vital for integrating different ABAP-based SAP systems, both on-premise and increasingly with cloud environments via new middleware like the SAP Cloud Connector and transport layers such as RFC over WebSockets. Despite past security efforts, Hagg's findings reveal that fundamental design flaws and implementation weaknesses persisted, allowing for credential leakage, authentication bypass, and ultimately, a full RCE exploit chain that operates unauthenticated.

Background

▶ Watch: Introduction and motivation for RFC vulnerability research (0:00)

The Remote Function Call (RFC) interface in SAP's ABAP application server is a foundational technology, crucial for inter-system communication and integration. Specifically, RFC Type 3 is designed to facilitate interactions between different ABAP-based SAP systems, forming the backbone of complex enterprise landscapes. Over the years, RFC has evolved from its traditional role in internal, on-premise infrastructures to support modern use cases, including integration with cloud services and internet-enabled communications via RFC over WebSockets. This continuous adaptation has expanded its attack surface, making comprehensive security analysis more critical than ever.

Security research into the RFC interface is not new. Mariano Nunez delivered a seminal talk at Black Hat Europe 16 years prior, in 2007, showcasing the first practical attacks against this interface. Subsequent research focused on protecting RFC credentials, both in transit and at rest, and the development of security tooling built upon available RFC software libraries. The vendor, SAP, also invested significant effort, introducing new frameworks like the Unified Connectivity Framework to enhance security by limiting externally callable functions. Despite these efforts and the interface's critical role, Fabian Hagg identified a gap: a lack of focused vulnerability research on the server-side implementation of RFC, particularly for Type 3 communications.

Hagg's motivation for this deep dive originated from a peculiar observation during a previous penetration testing project. While analyzing remote-enabled function modules, he encountered a scenario where an intended authorization check (specifically for the srfc authority object, which the kernel typically verifies) was mysteriously bypassed. This anomaly, which occurred in a lab environment set up with cloned SAP systems, hinted at an underlying issue with how authentication and authorization were handled within the RFC protocol itself. The primary objective of his subsequent research was to uncover the root cause of this unexpected behavior and to identify a vulnerability or a chain of vulnerabilities that could lead to code execution. This journey necessitated a meticulous dissection of the RFC Type 3 protocol, a task made challenging by the lack of public documentation and available tooling to fully understand its internal data structures and communication flows.

Key Findings

▶ Watch: Demo: Bypassing authentication with leaked tickets (27:00)

Fabian Hagg's research yielded several high-impact findings, starting with the elucidation of the RFC Type 3 protocol's inner workings and culminating in the discovery of critical design flaws and implementation vulnerabilities.

The initial phase involved understanding the RFC protocol's message flow and data structures, particularly for "RFC conversation packets" which were not covered by existing tools like Wireshark dissectors. Hagg discovered a fundamental Tag-Length-Value (TLV) pattern used to transmit various data types within what the kernel refers to as RFC data containers. Each container is identified by a unique "tag" (an integer), followed by its data length, the data value, and a repeating tag value. This structure, along with observed sanity checks for specific container chains, allowed him to reverse-engineer the protocol stack.

A crucial aspect of the protocol was the handling of "logon material" within the RFC sign-on data segment. This segment, containing user information and credentials, is processed by the kernel's ABI_SIGN_ON function and stored in a sign_on_control data structure in shared memory. Hagg identified a custom scrambling routine applied to sensitive data containers, including passwords and, notably, other unidentified containers. This scrambling, previously discussed in 2015, involves adding a 4-byte seed to the container, which then serves as an index into a hard-coded XOR pool within the kernel binary, performing a symmetric XOR operation on the plaintext.

The most impactful findings revolved around passwordless logon mechanisms that leverage these scrambled data containers. Hagg identified three specific data containers used to implement a hash-based message authentication code (HMAC) scheme for identifying RFC partners, effectively enabling passwordless authentication. These mechanisms are employed in two primary conversation types:

  1. Internal Conversations: Used for inter-system communication within the same SAP system (e.g., via the predefined RFC destination NONE) without a user context switch. This represents an implicit trust architecture.
  • Ticket Construction: An int_key (internal key) stored in the Secure Storage database (base64 encoded) is combined with a message string comprising the caller system identifier (SID), a 10-character installation number, and a request timestamp. The algorithm used is HMAC-SHA256. The resulting message digest is then scrambled for transmission.
  • Authentication Workflow: The calling instance crafts and sends the ticket and message components. The called instance verifies the SID, reconstructs the ticket using its shared int_key, and compares it with the received (unscrambled) ticket. Success authenticates the connection as the specified destination user. This mechanism directly explained Hagg's initial observation of an authorization bypass, as accidentally cloning a VM meant the two systems shared the exact same configuration and database, including the int_key, allowing the new system to implicitly trust the original without explicit authorization.
  1. Trusted Conversations: The foundation for configurable "trusted/trusting relationships" between SAP systems, allowing one system to log on to another without a password.
  • Security Method 2 (External Ticket): This newer method, introduced after a patch in 2011 for Security Method 1, implements an external ticket container. The key is a 64-byte message digest (randomly generated) stored in Secure Storage on the trusted system and replicated to the trusting system in the RFCSUSACL database table. The message string is more complex, including caller user, destination user, transaction ID, SID, and request timestamp. The algorithm used appears to be a custom, modified SHA-0 implementation with a custom number of rounds.
  • Authentication Workflow: A "single logon flag" indicates the desire for trusted authentication. The called instance checks this flag, verifies srfc_acl authority, and confirms an entry for the remote system in its database. If successful, it constructs and verifies the ticket.

Critically, Hagg identified several design flaws and implementation weaknesses associated with these ticket-based authentication schemes:

  • Credential Leakage: Both internal and external tickets are always sent out, regardless of whether the communication partner is part of the same system or in a trust relationship. This means the tickets are leaked to any receiving system.
  • No Replay Protection: There is no nonce value or session key used in ticket construction. For internal tickets, the timestamp is not validated on the server side; for external tickets, while a validity period can be configured, it is opted out by default. This makes the tickets susceptible to replay attacks.
  • Non-Unique Pre-shared Key: In trusted relationships, the pre-shared key (X_KEY) is not unique per relation but shared between all trusting systems. This allows a compromised trusting system to impersonate the trusted system to other trusting systems.

These flaws enable two main attack types:

  • RFC Loopback Attack: An attacker intercepts an ordinary request containing leaked tickets and replays them to the originating system or other trusting systems. Since the internal ticket doesn't integrate user information, arbitrary user accounts can be impersonated.
  • SAP Pass-the-Ticket Attack: Replaying the external ticket (especially to all trusting systems) grants access, leveraging the non-unique pre-shared key.

These findings laid the groundwork for further exploitation, demonstrating how fundamental architectural and implementation issues within a widely used protocol could lead to severe security compromises.

Technical Deep Dive

▶ Watch: Fuzzing reveals unauthenticated out-of-bounds write (29:50)

The technical depth of Fabian Hagg's research is evident in his detailed dissection of the RFC Type 3 protocol, the custom scrambling routine, the ticket-based authentication mechanisms, and the subsequent discovery of an out-of-bounds write vulnerability that enabled the full RCE exploit chain.

Protocol Dissection and Scrambling Routine

Hagg's initial work involved understanding the undocumented RFC Type 3 protocol. He identified a Tag-Length-Value (TLV) structure within RFC data containers, where a unique tag identifies the data type, data_length specifies its size, and the data_value holds the actual information. Crucially, sensitive data, including passwords and authentication tickets, are obscured using a custom scrambling routine. This routine, which adds a 4-byte seed to the data container, utilizes this seed to determine an index into a hard-coded XOR pool within the SAP kernel binary. A symmetric XOR operation is then performed between the plaintext data and the selected XOR pool entry, effectively scrambling the data. This seed value is also incorporated into the scrambling calculation process itself.

Passwordless Authentication Tickets and Their Flaws

The core of the credential leakage and authentication bypass vulnerabilities lies in two primary ticket types:

  1. Internal Conversation Ticket:
  • Key: int_key, a base64-encoded value stored in the Secure Storage database.
  • Message String: Concatenation of the caller system identifier (SID), a 10-character SAP installation number, and a request timestamp.
  • Algorithm: HMAC-SHA256.
  • Construction: A simple Python POC script was developed to demonstrate how this ticket is crafted, scrambled, and made ready for transmission. The key insight here is that within the same SAP system, all application servers share the same database and thus the same int_key, enabling implicit trust.
  • Flaws: No nonces are used, and the request timestamp is not validated on the server side. This makes the internal ticket highly susceptible to replay attacks and allows for impersonation of arbitrary user accounts because the ticket itself does not contain user-specific context.
  1. External Conversation Ticket (Security Method 2):
  • Key: A 64-byte message digest (randomly generated using a web_site_rand_gen), stored in Secure Storage on the trusted system and replicated to the trusting system in the RFCSUSACL database table.
  • Message String: Includes the caller user, destination user, transaction ID, system identifier (SID), and request timestamp.
  • Algorithm: A custom, modified SHA-0 implementation with a non-standard number of rounds.
  • Construction: Another script was developed to generate and scramble this external ticket.
  • Flaws: While a validity period can be configured for trusted relationships, it is disabled by default. More critically, the pre-shared key (X_KEY) is not unique per trust relationship, meaning it's shared across all trusting systems. This allows a compromised trusting system to craft tickets and authenticate to other trusting systems, enabling widespread lateral movement.

These design flaws lead to two primary attack vectors: RFC Loopback Attack (replaying tickets to the originating system or other trusting systems) and SAP Pass-the-Ticket Attack (leveraging the non-unique pre-shared key for broader access). These vulnerabilities affect not only RFC Type 3 but also other transport layers like HTTP and RFC over WebSockets, where this logon material is transferred (scrambled) in custom HTTP headers.

Unauthenticated Out-of-Bounds Write Vulnerability

Recognizing the need for a prerequisite to obtain these leaked tickets or pre-shared secrets, Hagg turned to fuzzing. He adapted his Python script to fuzz RFC conversation packets, leveraging his understanding of the protocol's data structures. After a few attempts, he triggered a segmentation fault in the kernel binary, specifically within the scrambling routine.

The root cause was an out-of-bounds (OOB) write vulnerability. The scrambling routine receives a pointer to an 80-byte fixed-size buffer within the sign_on_control structure. It also receives the seed value and an effective_container_size, which is calculated from the attacker-controlled data_length value of the RFC data container minus the fixed 4-byte seed. The routine then enters an XOR schedule loop, iterating over each byte of the scrambled data and using this effective_container_size as the loop's break condition. By providing an effective_container_size greater than the 80-byte buffer, the attacker gains control over the loop's termination, causing the XOR schedule to operate on memory regions next to the intended buffer.

While this OOB write is triggered before authentication and the attacker is limited by the static conversion map of the XOR pool, combining different seed values allows for greater granularity in what can be written into memory. Hagg initially failed to turn this directly into RCE but found a more reliable path to an authentication bypass. By brute-forcing seed values with an overlong ticket, it was possible to corrupt specific internal flags within the sign_on_control structure. These flags, normally set by the kernel based on imported logon material, can be manipulated to gain limited control over the kernel function orchestrating authentication. This bypass grants access to the system within the virtual user context of the SUBSYS user.

The SUBSYS User and Server-Side Request Forgery (SSRF)

The SUBSYS user is a virtual account with no user master record or application-layer authorizations. Initially, this seemed to render the OOB write-based bypass useless. However, Hagg discovered that certain hard-coded function names (beyond the well-known SRFC function group, which allows unauthenticated calls) still require authentication but do not require the srfc authority object. This meant the SUBSYS user, though unprivileged at the application layer, could call specific ABAP code at a high level.

Investigating these functions, Hagg identified two Server-Side Request Forgery (SSRF) primitives. These functions take an import parameter named destination_name. While typically referring to RFC destinations configured in sm59, official documentation reveals that dynamic destinations can be provided in the format hostname system_identifier system_number. This allows the SUBSYS user to force the target SAP application server to perform RFC requests to an arbitrary hostname and a port within the range 3300-3399.

Unauthenticated RCE Exploit Chain

Fabian Hagg successfully chained these vulnerabilities to achieve unauthenticated Remote Code Execution:

  1. Initial Connection: The exploit script optionally calls RFC_SYSTEM_INFO.
  2. Authentication Bypass: It triggers the OOB write vulnerability with an overlong ticket and specific seed values to corrupt internal flags in sign_on_control. This bypasses authentication and gains access as the virtual SUBSYS user.
  3. SSRF Callback: Using the SSRF primitive (as SUBSYS), the target SAP system is forced to connect back to the attacker's rogue server.
  4. Credential Leak (SUBSYS Tickets): During this callback, the target system attempts to authenticate as SUBSYS, leaking its internal and external tickets to the attacker's rogue server.
  5. Replay and Internal Conversation: The attacker replays these SUBSYS tickets, now establishing an authenticated connection as SUBSYS but within an "internal conversation" context. This context allows calling arbitrary function modules without the srfc authority object.
  6. Arbitrary Function Module Creation: As SUBSYS, the attacker invokes the function module RS_FUNCTION_MODULE_INSERT. This function, originally presented by Andreas Wiegenstein at Troopers 2012 (with updates in 2014), allows creating new ABAP functions in the system, bypassing client and system modifiability settings and even developer permission checks (due to its reliance on a kernel module that simply checks the replayed tickets).
  7. Payload Delivery: The attacker uses RS_FUNCTION_MODULE_INSERT to create a new ABAP function module containing a second-stage payload (e.g., a reverse shell). This payload is carefully crafted to avoid triggering any authority checks when invoked.
  8. RCE: The newly created function module is then executed (as SUBSYS), leading to arbitrary code execution as the <sid>adm user.

This complex chain demonstrates a profound understanding of SAP's kernel, protocol, and application layer interactions, showcasing how deep technical analysis can expose critical vulnerabilities even in mature, widely deployed software.

Demo / Proof of Concept

▶ Watch: Patching challenges and defense recommendations (44:00)

Fabian Hagg effectively demonstrated the practical implications of his findings through a compelling Proof of Concept (PoC), focusing on the credential leakage and replay attack via HTTP, a transport layer also affected by these design flaws.

The demonstration began by illustrating a common scenario: a network administrator configuring an SAP system to connect with an external "supplier" system. In the PoC, the "supplier" was simulated by an attacker running a simple netcat listener. The administrator, logged in as user "Alice," performs a routine connection test, specifying "Alice" as the destination user.

This seemingly innocuous connection test triggers an outgoing HTTP request from the SAP system. Crucially, this request includes a custom HTTP header containing the scrambled internal and external tickets. The attacker's netcat listener captures this request, revealing the scrambled header value.

Hagg then showcased two Python scripts he developed: one to decrypt and another to encrypt/generate these header values. Using the decryption script, the captured scrambled header value was immediately decrypted, exposing both the internal and external tickets in plaintext. This vividly demonstrated the core vulnerability: credential leakage to any party capable of intercepting or receiving such a request.

With the raw, decrypted header value in hand, the attacker then proceeds to the authentication bypass phase. The attacker intercepts a legitimate request to the targeted SAP system's Fiori Launchpad (e.g., a standard login page). Before forwarding the request to the SAP system, the attacker injects the previously captured and decrypted custom HTTP header value into the intercepted request. Upon forwarding, the SAP system processes the request, sees the valid (though replayed) tickets in the header, and grants access.

The result was immediate and striking: the attacker, without providing any password or valid credentials for user Alice, successfully bypassed the Fiori Launchpad's authentication and gained full access to the system as user Alice. This access could then be leveraged for further malicious actions within the SAP environment.

Hagg emphasized that while the demo focused on HTTP for its visual clarity and ease of demonstration, the same type of attack is possible via other transport layers, including RFC Type 3 itself. The white paper accompanying the talk includes simple socket listener PoCs to replicate the attack using RFC communication, further underscoring the widespread applicability of these vulnerabilities. The demo effectively conveyed the critical yet trivial nature of exploiting these design flaws once the underlying mechanisms of ticket generation and transmission are understood.

Defensive Implications

▶ Watch: Q&A: Patch details and Wireshark dissector (50:50)

The vulnerabilities uncovered by Fabian Hagg carry significant defensive implications for SAP users, ranging from the immediate need for patching to long-term architectural and monitoring strategies. The complex nature of the affected systems and the vulnerabilities themselves means that a multi-faceted approach is required.

Vulnerable Characteristics and Impact

The identified attack vectors exhibit highly undesirable characteristics:

  • Remotely Exploitable: Attacks can be launched from anywhere with network access to the SAP system.
  • No User Interaction Required: The RCE chain can be executed without any user involvement on the target system.
  • Automatable: The entire exploit chain can be scripted and automated.
  • Lateral Movement: The credential leakage and replay attacks, especially with the non-unique pre-shared key in trusted relationships, make lateral movement across an SAP landscape highly probable.
  • Increased Distribution: In central hub architectures (e.g., a Solution Manager connecting to multiple satellite systems), a compromise of the hub could rapidly spread to numerous connected systems.
  • Hosted Environments: The attack could immediately affect multiple system landscapes if a hosting provider operates a shared Solution Manager connecting to various customers.

Detection Challenges

A critical defensive challenge lies in detecting the exploitation of the SUBSYS user context. Even if security logs are enabled and integrated with a SIEM for regular review, the activity of the virtual SUBSYS user account may not be logged by default. Hagg pointed out that the SAP Security Baseline Template, version 4.2.4, actually recommends not logging events associated with this virtual user account. This default configuration creates a significant blind spot, potentially allowing attacks via the SUBSYS user to go unnoticed.

Patching and Mitigation

SAP responsibly disclosed the vulnerabilities two years prior to the talk (in 2021), and patches were released, with the final patch for the trusted/trusting architecture design flaws arriving in January 2023. However, implementing these patches presents several challenges for SAP users:

  • Complexity: Patches require updates to both the kernel and ABAP core components. These may have additional dependencies that need to be installed first.
  • Post-Installation Steps: Crucially, simply applying the patches is not enough. Users must perform complex post-installation steps, including migrating all trusted/trusting RFC destinations across their entire system landscape.
  • Profile Parameter: After migration, a specific profile parameter must be set to ensure that only secure connections are allowed, fully enforcing the new security measures.
  • Organizational Maturity: The ease of implementing these patches depends heavily on the organization's asset management, change management, and configuration management maturity. Knowing all existing RFC destinations is key.
  • Vendor Support: SAP has provided tools, such as policies for Focused Run and an FAQ for the specific security note, to assist customers with the patching process.

Workarounds and Proactive Measures (If Patching is Not an Option)

For situations where immediate patching is not feasible, Hagg recommended several workarounds and general proactive measures:

  • Monitor Secure Storage: Restrict and monitor access to the database tables where the pre-shared secrets (X_KEY and INT_KEY) are stored.
  • Monitor Key Exchange Function: Restrict and monitor function calls to the specific function module used to exchange the X_KEY when setting up trust relationships.
  • Custom Secure Storage Keys: Use custom keys for all Secure Storage types, rather than relying on defaults.
  • Enforce SNC and TLS: Mandate the use of Secure Network Communications (SNC) and TLS for all inbound and outbound RFC communications to encrypt data in transit.
  • Least Privilege: Remove any unnecessary permissions for the srfc and srfc_acl authority objects.
  • Unified Connectivity Framework: Implement the Unified Connectivity Framework to strictly limit which function modules can be called remotely. This acts as an application-layer firewall for RFC.

Fabian Hagg's research underscores a fundamental principle in enterprise software security: in historically grown, highly customizable products like SAP, security is a shared responsibility. Both the vendor (through robust design and timely patching) and the users (through diligent patching, configuration, monitoring, and proactive measures) must actively participate to minimize and mitigate the impact of such deeply embedded design flaws. The fact that the SUBSYS user activity is often not logged highlights the critical need for customers to review and customize their security audit log configurations beyond vendor defaults.

Key Takeaways

  • Deep Protocol Dissection is Crucial: The RFC Type 3 protocol, despite its age and prevalence, had undocumented internal structures and communication flows. Reverse engineering these, including the custom scrambling routine and TLV patterns, was fundamental to uncovering vulnerabilities.
  • Design Flaws Lead to Credential Leakage and Replay Attacks: The automatic transmission of internal and external tickets, combined with a lack of nonces, inadequate timestamp validation, and non-unique pre-shared keys, created critical credential leakage and replay attack opportunities across RFC, HTTP, and RFC over WebSockets.
  • Unauthenticated OOB Write and Authentication Bypass: A subtle out-of-bounds write vulnerability in the scrambling routine, triggered by attacker-controlled data_length values, allowed for the corruption of internal kernel flags, leading to an unauthenticated authentication bypass as the virtual SUBSYS user.
  • Chaining Vulnerabilities for RCE: The SUBSYS user, initially perceived as powerless, was leveraged via identified SSRF primitives to force callbacks, obtain SUBSYS tickets, and then use the RS_FUNCTION_MODULE_INSERT function (which itself bypassed authorization checks due to the replayed tickets) to inject and execute arbitrary ABAP code, achieving unauthenticated RCE.
  • Complexity of Patching and Shared Responsibility: Patching such deeply integrated vulnerabilities in a complex, highly customized system like SAP requires significant effort, involving kernel, ABAP core, and extensive post-installation migration steps. This highlights the shared responsibility model between vendor and user in securing enterprise software.
  • Blind Spots in Logging and Monitoring: The default recommendation to not log SUBSYS user activity creates a critical blind spot for detection. Organizations must review and customize their security audit logs to ensure comprehensive coverage, especially for virtual or system-level accounts.

About the Speaker(s)

Fabian Hagg is a Technical Security Consultant and the Head of Security for SAP Services at SEC Consult. Based in Vienna, he leads a team specializing in penetration tests and security assessments of various SAP software applications and products. Fabian is also currently pursuing a Masters program in I.T. security at the Technicum in Vienna. This presentation at TROOPERS marked his first-ever security conference talk, a significant debut showcasing extensive research into SAP's RFC interface. He acknowledged the support of his former colleagues, Alex and Rasheen, and the broader SAP security research community for helping him delve into the field.

Reviews

Dr. Zero (Offensive Security Researcher) — MUST SEE

Fabian Hagg ripped apart SAP's undocumented RFC Type 3 protocol and chained an out-of-bounds write, an auth bypass, and an SSRF into unauthenticated RCE. This is exactly what top-tier offensive research looks like. If you defend SAP environments and haven't watched this, you're flying blind.

Heather Calloway (CISO) — MUST SEE

Unauthenticated RCE in SAP RFC is a nightmare scenario for any enterprise, but the real issue here is the remediation. This isn't a standard patch cycle; it requires a manual, cross-functional IT migration that your SOC won't see coming because SAP's default baseline recommends blinding your logs to the exploited account. I'd forward this directly to the CIO and my head of ERP security.

→ Top-rated talks at TROOPERS23

All talks from TROOPERS23