The Pre-Internet Computer: Hacking a System Older Than the Web
Adam Toscher
Overview
In his CypherCon talk, "The Pre-Internet Computer: Hacking a System Older Than the Web," Adam Toscher shines a critical light on a foundational yet often-ignored segment of global infrastructure: mainframes. These "Big Iron Systems," as Toscher refers to them, process an astounding 30 billion transactions daily, underpinning critical sectors like finance, government, and logistics. Despite their pervasive role in modern society, mainframes are frequently deemed "out of scope" by red teams, largely due to a lack of specialized tooling, esoteric jargon, and a widespread misconception that their age equates to irrelevance or impenetrable security.

Key moments
- 2:20 Why mainframe security is overlooked
- 4:20 IBM's historical influence and massive investment
- 10:00 Mainframe security's core problem: no EDR
- 17:00 Key mainframe control planes (TSO, CICS, JES, RACF)
- 20:00 Attacking mainframes via configuration, not CVEs
- 23:45 Privilege escalation using job hijacking
- 24:45 Live demo of AI-powered mainframe red team tool
- 31:45 Mainframe security based on execution paths
The Pre-Internet Computer: Hacking a System Older Than the Web
Speakers: Adam Toscher
Conference: CypherCon
YouTube: https://www.youtube.com/watch?v=mqrE8FMvmrQ
Overview
In his CypherCon talk, "The Pre-Internet Computer: Hacking a System Older Than the Web," Adam Toscher shines a critical light on a foundational yet often-ignored segment of global infrastructure: mainframes. These "Big Iron Systems," as Toscher refers to them, process an astounding 30 billion transactions daily, underpinning critical sectors like finance, government, and logistics. Despite their pervasive role in modern society, mainframes are frequently deemed "out of scope" by red teams, largely due to a lack of specialized tooling, esoteric jargon, and a widespread misconception that their age equates to irrelevance or impenetrable security.
Toscher's presentation challenges this dangerous oversight, arguing that the security industry's current threat models, tools, and frameworks (like MITRE ATT&CK or OWASP) are woefully inadequate for assessing mainframe vulnerabilities. He highlights that legacy code, some dating back to 1964, remains in active use, compounded by a promise of backwards compatibility that, while beneficial for stability, introduces significant security risks. The talk aims to demystify mainframe architecture and expose how fundamental design and configuration issues, rather than complex memory corruption exploits, provide clear pathways for compromise, even for systems older than the internet itself.
The core message is a stark warning: the perceived security of mainframes is often a product of obscurity and a conceptual gap in modern cybersecurity. Toscher demonstrates that with the right understanding and tools, these critical systems are vulnerable to sophisticated attacks, primarily through exploiting their unique control planes and an inherited trust model. By bridging the knowledge gap with a novel, AI-assisted platform, he seeks to empower a new generation of security professionals to effectively evaluate and secure these indispensable components of our digital world.
Background
▶ Watch: Why mainframe security is overlooked (2:20)
The history of mainframes is deeply intertwined with the very genesis of computing, largely spearheaded by IBM. As Toscher recounts, IBM's early commitment to mainframes was monumental, with investments like the $5 billion (in today's dollars, exceeding the Manhattan Project's cost) poured into the development of the System/360 in the 1960s. This initial architecture laid the groundwork for many computing concepts we take for granted today, including abstraction, virtualization, and virtual memory. IBM's influence extended to fabricating crucial chip components in upstate New York, a testament to their industrial dominance.
The mainframe architecture evolved through generations: from the System/360 to the System/370 (introducing virtual memory and MVS - Multiple Virtual Storage), then the S390 in the late 90s, and finally ZOS in the 2000s. Despite these rebrandings, Toscher emphasizes a crucial point: "the infrastructure and the actual, you know, underbelly of these things is the same as it was like when I used to work there." This unwavering commitment to backwards compatibility, a promise made by IBM founder Thomas J. Watson, means that code from the 1960s can still run on modern ZOS systems, carrying with it decades of potential design flaws and configuration weaknesses.
Mainframes operate on a fundamentally different paradigm than modern distributed systems. They are not secured by services and ports in the traditional sense, but by "control over execution paths and data sets." Early interaction was via TN3270 dumb terminals, directly communicating with the mainframe without a standard TCP/IP stack (which had to be retrofitted later). Key components like RACF (Resource Access Control Facility) handle authentication and authorization, while JES (Job Entry Subsystem) manages batch processing and deferred job execution, a critical mechanism for privilege escalation. TSO (Time Sharing Option) provides a command-line interface akin to a modern shell, and CICS (Customer Information Control System) is the application execution environment.
The problem, as Toscher articulates, is primarily conceptual. The security industry has developed robust threat models, tools, and frameworks for distributed, cloud-native, and Unix-like environments, but these do not translate effectively to the mainframe world. There's no equivalent of an EDR (Endpoint Detection and Response) agent for ZOS, and even IBM's proprietary SIEMs offer only batched, non-real-time data. This gap has led to mainframes being overlooked by red teams, who often stop at the perimeter, missing the "really juicy information where the credit cards are stored." Toscher credits pioneers like Philip Young (formerly of the Fed, now director at NetSPI) and Soldier of Fortran for their foundational work in mainframe hacking, which heavily influenced his own research and tooling. He also mentions Chad, who developed the first Metasploit module for mainframes.
Key Findings
▶ Watch: Mainframe security's core problem: no EDR (10:00)
Adam Toscher's talk highlights several critical findings that underscore the unique security challenges and vulnerabilities inherent in mainframe systems:
- Conceptual Blind Spot: The most significant finding is the pervasive conceptual gap in the security industry. Modern threat models, tools, and frameworks (e.g., MITRE ATT&CK, OWASP) are designed for environments fundamentally different from mainframes. This leads to a lack of effective security visibility; for instance, "there's not even an EDR for ZOS," and existing IBM SIMs provide only batched, non-real-time data, leaving defenders largely blind to ongoing attacks.
- Backwards Compatibility as a Weakness: IBM's long-standing promise of backwards compatibility, while ensuring stability and longevity, is a double-edged sword for security. Code from as far back as 1964 can still run on contemporary ZOS systems, meaning decades-old design flaws and configuration paradigms persist. This makes mainframes inherently susceptible to vulnerabilities that have been "fixed" in modern computing but remain exploitable in this legacy context.
- Vulnerabilities are Design and Configuration Issues, Not CVEs: Toscher emphatically states that mainframe compromise pathways are "a sequence of configuration and design issues," not memory corruption exploits or traditional CVEs. He notes that IBM often ignores or slowly addresses reported vulnerabilities, implying that the fundamental architecture itself presents the attack surface. This shifts the focus from patching specific bugs to understanding and exploiting system-level trust and execution models.
- Overlooked Attack Surface: Mainframes are not secured by "services and ports" in the conventional sense. Instead, their security relies on "control over execution paths and data sets." This distinction is crucial; traditional network scanning and penetration testing methodologies often miss the true attack vectors.
- Pervasive Exposure and Default Credentials: Despite their critical nature, many mainframes are discoverable via services like Shodan, exposing unencrypted TN3270 sessions (often on port 2323) to the internet. These systems frequently rely on default credentials and weak access controls, providing straightforward initial access points for attackers.
- High-Value, Unprotected Data: Mainframes are the repositories of incredibly sensitive data, with "every single major credit card provider" relying on them. Processing 30 billion transactions daily, these systems are prime targets for data exfiltration, yet Toscher reports that "73% [have] zero EDR agent."
- Exploitation of Federated Control Planes: Mainframes feature a "federated" architecture with multiple interconnected control planes (RACF, JES, TSO, CICS, VTAM, TN3270). Owning one component necessitates traversing these planes. Attackers can exploit the interactions between these systems, particularly the deferred execution model of JES and the use of JCL (Job Control Language), to achieve privilege escalation and execution.
These findings collectively paint a picture of highly critical, yet fundamentally misunderstood and inadequately secured, infrastructure.
Technical Deep Dive
▶ Watch: Attacking mainframes via configuration, not CVEs (20:00)
The technical core of mainframe hacking, as articulated by Adam Toscher, revolves around understanding and exploiting the system's unique, federated architecture and control planes. Unlike modern systems that rely on a hierarchical file system and network services, mainframes operate on distinct logical components that interact in specific, often privileged, ways.
The primary access vector is typically an exposed TN3270 session, which is essentially a dumb terminal emulation. Toscher notes these are often found via Shodan on unencrypted ports, commonly 2323, functioning much like an old-school Telnet session. Once connected, an attacker interacts with TSO (Time Sharing Option), which serves as the equivalent of a modern command-line interface or shell.
Central to mainframe security is RACF (Resource Access Control Facility), IBM's primary security product for authentication and authorization. It governs user access to resources and execution paths. While RACF is designed to oversee processes, Toscher explains that it can be "tricked" by manipulating user identities or exploiting specific workflow vulnerabilities, similar to how watchdog services can be bypassed in other environments. Another security product, Top Secret, is also mentioned as an alternative.
The true power of mainframe compromise lies in understanding JES (Job Entry Subsystem) and JCL (Job Control Language). JES manages batch processing, where jobs are submitted to a queue for deferred execution. A critical characteristic is the unpredictable timing of job execution – "You don't know if it's going to run within a minute... within an hour." This deferred execution model is a key attack surface. JCL, a legacy from punch card days, is the scripting language used to define and control these jobs. It dictates what programs run, what data sets they access, and under what user context.
Toscher draws an analogy to DLL hijacking to explain a common privilege escalation technique. In this scenario, a low-level user can exploit a "step-up environmental command" vulnerability within the mainframe's job processing. By manipulating the job queue, a low-privileged user can essentially "grab a job that is sitting in the pool of batches" that belongs to a higher-privileged user or system process. When this hijacked job executes, it inherits the identity and privileges of the original, higher-level user, effectively granting the attacker superuser access. This is a design flaw rather than a memory corruption bug, leveraging the inherent trust model of the batch processing system.
Other critical components of the mainframe ecosystem include:
- VTAM (Virtual Telecommunications Access Method): This acts as the network and session fabric, responsible for communication between terminals and applications.
- CICS (Customer Information Control System): This is the dedicated system where most applications run. Toscher mentions that it's possible to enumerate these applications, providing further attack surface.
- FDS (File Data System): While not explicitly detailed, this refers to the data storage mechanisms, often hierarchical and complex.
The talk also touches upon EBCDIC (Extended Binary Coded Decimal Interchange Code), IBM's proprietary character encoding standard. While seemingly minor, EBCDIC is a significant technical detail for attackers. When analyzing wire traffic (e.g., unencrypted TN3270 sessions), data will be in EBCDIC, not ASCII. As Toscher notes, with an EBCDIC decoder, it's possible to "sometimes get usernames and passwords" directly from the wire, highlighting a fundamental lack of encryption in legacy deployments.
Furthermore, Toscher points out that FTP clients can be a vector for compromise. By connecting to a mainframe's FTP client, attackers can enumerate directories and potentially submit malicious JCL jobs into the JES queue, leveraging the system's trust in its own internal job submission mechanisms. This entire attack path, from finding exposed systems to privilege escalation via JCL, represents a sequence of configuration and design issues that have persisted due to the mainframe's unique evolution and IBM's commitment to backwards compatibility.
Demo / Proof of Concept
▶ Watch: Privilege escalation using job hijacking (23:45)
Adam Toscher's demonstration showcased a custom-built platform designed to demystify and facilitate mainframe hacking, specifically targeting a "turnkey free version of the operating system" from the 1980s (referred to as CICS with a K). This choice was deliberate, allowing him to demonstrate full functionality without infringing on IBM's stringent copyright on modern ZOS systems.
The platform's most innovative feature is its AI agent integration. Utilizing free Large Language Models (LLMs) like Open LLaMA, the tool provides real-time, context-aware assistance to the user. As Toscher navigates the TN3270 terminal interface, the AI agent, visible on the screen, can analyze the current screen content. For instance, if a user is presented with a complex JCL script, they can click an AI button, and the agent will offer "red team prompts" to guide them or "enumerate JCL to submit it." This functionality is crucial for bridging the knowledge gap, allowing even those without deep mainframe expertise to understand and interact with the esoteric commands and interfaces. Toscher envisions this as a "red team tutor," helping users get "unstuck" and learn the ropes.
The demo highlighted several modules within the platform:
- Red Team Tutor: This module incorporates "tracks" from legendary mainframe hackers like Soldier of Fortran, providing structured learning paths for common attack techniques.
- FTP Client: Toscher demonstrated connecting to an FTP client on the mainframe, showcasing how easy it was to enumerate system directories and files. He explained that submitting jobs via FTP into the JES queue was one of his earliest successful mainframe hacks, underscoring the inherent insecurity of such configurations.
- Assessment Tools: The platform includes scripts for system enumeration, including listing VM sessions. These tools can generate reports, streamlining the reconnaissance phase of an engagement. Toscher mentioned "a script that I actually stole from Philip Young and kind of incorporated here," highlighting the collaborative nature of the mainframe security community.
- EBCDIC Decoder: A practical tool for analyzing raw network traffic, allowing users to decode IBM's proprietary EBCDIC character set. As Toscher noted, this can reveal sensitive information like usernames and passwords captured "on the wire."
- Bloodhound Graph (conceptual): Although not shown live due to time constraints, Toscher mentioned the capability to generate a Bloodhound-like graph once data is imported into the platform, visualizing relationships and potential attack paths within the mainframe's complex permissions and execution environment.
- RAG (Retrieval Augmented Generation): The platform also features a RAG system that reads "rautonous walkthroughs," allowing users to progress at their own pace through various attack scenarios.
A key advantage stressed by Toscher is the platform's offline capability. He runs it successfully on an "old 5-year-old M1 MacBook," emphasizing that powerful, free LLMs can be utilized locally, making the tool accessible and self-contained for security professionals in environments where internet connectivity might be restricted or undesirable. The overarching goal of this innovative platform is to democratize mainframe security assessment, enabling "your average pentester" to engage with these complex systems without requiring the years of specialized experience traditionally held by mainframe SMEs (Subject Matter Experts).
Defensive Implications
▶ Watch: Mainframe security based on execution paths (31:45)
The insights shared by Adam Toscher about mainframe vulnerabilities carry significant defensive implications for organizations that rely on these critical systems. Recognizing that mainframes are not secured by modern paradigms, defenders must fundamentally shift their approach.
- Prioritize Mainframe Security Awareness and Inventory: The first step is acknowledging that mainframes are high-value, high-risk assets that are often overlooked. Organizations must conduct a comprehensive inventory of all mainframe systems, understanding their role in critical business processes and the sensitive data they handle. Security teams, often focused on cloud and distributed systems, need to be educated on the unique nature of mainframe security.
- Eliminate External Exposure: Toscher's discovery of unencrypted TN3270 sessions (port 2323) exposed via Shodan is a critical red flag. All such external exposures must be immediately remediated. Mainframe access should be restricted to internal networks, ideally segmented, and secured with strong authentication and, where possible, encryption. Default installations often lack a TCP/IP stack, but when retrofitted, secure configurations are paramount.
- Strict Access Control and Default Credential Management: RACF (or Top Secret) configurations must be rigorously reviewed and hardened. All default credentials must be changed immediately upon deployment and regularly rotated. Access policies should follow the principle of least privilege, ensuring users and processes only have the exact permissions required for their function. This includes scrutinizing batch job submission permissions.
- Monitor and Audit Job Control Language (JCL): Given that privilege escalation often hinges on exploiting JES and JCL, defenders must implement robust monitoring and auditing of JCL submissions and job execution. Anomalous JCL, especially from low-privileged users attempting to submit jobs with elevated privileges, should trigger immediate alerts. Understanding the normal patterns of JCL execution is vital to detect deviations.
- Address the "DLL Hijacking" Equivalent: The vulnerability allowing low-privileged users to inherit identities from high-privileged batch jobs requires specific mitigation. This might involve re-evaluating the trust model between jobs, implementing stricter controls on job queue manipulation, and ensuring that batch processes run with the absolute minimum necessary privileges. Regular audits of job definitions and their associated permissions are essential.
- Secure FTP and Other Ancillary Services: As demonstrated, even seemingly innocuous services like FTP can be attack vectors for job submission and enumeration. Any service interacting with the mainframe must be secured, configured for least privilege, and monitored for suspicious activity. Unencrypted data transmission (e.g., via EBCDIC on the wire) should be addressed where possible, though often challenging with legacy systems.
- Bridge the Tooling Gap: Organizations should explore and adopt specialized tools and frameworks, like the one Toscher demonstrated, that are designed for mainframe security assessment. Traditional EDRs and modern SIEMs are insufficient; bespoke solutions or integrations that can parse mainframe logs and activity in real-time (or near real-time, if true real-time is impossible) are necessary.
- Training and Expertise Development: Given the scarcity of mainframe security experts, organizations must invest in training their existing security teams. This includes educating them on mainframe architecture, control planes (RACF, JES, TSO, CICS), JCL, and common attack methodologies. Building internal expertise is crucial for long-term resilience.
- Embrace "Control Over Execution Paths and Data Sets": Defenders must internalize that mainframe security is fundamentally about controlling execution paths and access to data sets, not just network ports. This requires a deep understanding of how processes interact, how data is stored, and how privileges are managed within the mainframe environment.
By adopting these defensive postures, organizations can move beyond a false sense of security derived from obscurity and proactively protect their indispensable mainframe assets.
Key Takeaways
- Mainframes are Critical and Overlooked: Despite processing 30 billion transactions daily and holding sensitive data (e.g., credit cards), mainframes are often ignored by red teams and lack modern security tooling like EDR.
- Security Paradigm Shift Required: Mainframe security is fundamentally different; it's about "control over execution paths and data sets," not traditional network services and ports.
- Backwards Compatibility is a Vulnerability: IBM's promise of backwards compatibility means decades-old design flaws and code (some from 1964) persist, leading to configuration and design issues as primary attack vectors, not memory corruption.
- Default Credentials and Exposure are Common: Many mainframes expose unencrypted TN3270 sessions (port 2323) to the internet, often protected only by default or weak credentials, providing straightforward initial access.
- Exploiting Federated Control Planes: Privilege escalation often involves manipulating the JES (Job Entry Subsystem) and JCL (Job Control Language), using techniques akin to "DLL hijacking" to inherit higher privileges from deferred batch jobs.
- AI-Assisted Tools Bridge the Knowledge Gap: New platforms, like the one demonstrated, leverage AI to demystify mainframe hacking, providing real-time guidance and enabling average pentesters to assess these complex systems effectively.
About the Speaker(s)
Adam Toscher is a seasoned security professional with 20 years of experience in the field. His background includes significant time working at IBM, where he interned on systems like the S390 and contributed to porting Linux applications to mainframe platforms. This hands-on experience provided him with a deep, practical understanding of mainframe architecture and operation. Passionate about bringing modern security methodologies to these often-overlooked systems, Toscher has developed an innovative, AI-assisted platform designed to demystify mainframe hacking and empower a broader range of security professionals to assess and secure them. His work aims to highlight the critical importance of mainframes in today's infrastructure and address the significant security blind spots that currently exist.
Reviews
Dr. Zero (Offensive Security Researcher) — STRONG ACCEPT
Toscher takes the black magic out of mainframe hacking and builds a bridge for modern red teams who run away screaming when they see EBCDIC. The underlying attack paths are well-documented by Philip Young and Soldier of Fortran, but packaging them into an offline LLM tool to translate ancient JCL into actionable attacks is a massive win for practical impact.
Heather Calloway (CISO) — STRONG ACCEPT
Toscher dismantles the persistent illusion that mainframes are secure by virtue of their obscurity and age. He demonstrates that these systems—which process the bulk of global financial transactions—are riddled with legacy trust flaws and routinely excluded from standard pentest scopes. If your organization relies on Big Iron, this is required viewing for your security architecture and internal audit teams.