How the Vietnam War created single sign-on – and how it’s evolved since
Connor Peshek
Overview
In his CypherCon talk, "How the Vietnam War created single sign-on – and how it’s evolved since," Connor Peshek takes attendees on an unexpected journey through military history, academic innovation, and the birth of the internet to trace the origins and evolution of Single Sign-On (SSO). Far from being a modern corporate convenience, Peshek argues that the fundamental principles of SSO emerged from urgent wartime needs for secure and scalable communication, specifically during the Vietnam War.

Key moments
- 2:00 Talk introduction and WWII communication challenges
- 4:30 Green Hornet/SIGSALY: First secure voice encryption
- 10:30 Bellfield system: Centralized keys, first SSO concept
- 15:30 Kerberos: Bellfield's unclassified clone for MIT Athena
- 20:00 SAML: XML-based SSO for early corporate web
- 26:30 OAuth/OpenID Connect: Modern web authorization and identity
- 28:50 Q&A: Jerome Saltzer and classified Bellfield system
How the Vietnam War created single sign-on – and how it’s evolved since
Speakers: Connor Peshek
Conference: CypherCon
YouTube: https://www.youtube.com/watch?v=mEE9S1UshR8
Overview
In his CypherCon talk, "How the Vietnam War created single sign-on – and how it’s evolved since," Connor Peshek takes attendees on an unexpected journey through military history, academic innovation, and the birth of the internet to trace the origins and evolution of Single Sign-On (SSO). Far from being a modern corporate convenience, Peshek argues that the fundamental principles of SSO emerged from urgent wartime needs for secure and scalable communication, specifically during the Vietnam War.
Peshek, a self-taught JavaScript engineer with experience at Cloudflare and Authentik (an open-source alternative to Okta), brings a unique perspective to this historical narrative. His research into authentication protocols, sparked by his work in the SSO space, revealed a history far more compelling than often perceived. The talk highlights how seemingly disparate events—from the cryptographic challenges of World War II to MIT's pioneering Project Athena—laid the groundwork for the authentication systems that underpin virtually all modern digital interactions.
This article delves into Peshek's compelling historical account, exploring the technological breakthroughs and strategic imperatives that shaped SSO. It uncovers how military requirements for secure, efficient communication led to the development of centralized authentication mechanisms, which were later adapted and refined for academic and eventually commercial use. The talk serves as a potent reminder that many foundational technologies in cybersecurity have deep, often forgotten, roots in critical historical contexts.
Background
▶ Watch: Talk introduction and WWII communication challenges (2:00)
The journey to Single Sign-On begins not in a server room, but on the battlefields of World War II. In 1941, secure voice communication was a critical, unmet need. The primary tool available, the A3 Scrambler, was an analog device that inverted frequencies to obfuscate speech. While innovative for its time, a 1970s Bell Labs retrospective revealed it could be easily cracked by an average high schooler. Indeed, the Germans routinely intercepted these communications, a fact known to high-level generals like Churchill and FDR, who used it despite their suspicions. The devastating bombing of Pearl Harbor, which could have been averted if a critical warning had been sent via secure, fast communication, underscored this urgent problem. The general opted for slow, coded radio telegraphy over the insecure A3, and the message arrived too late.
In response, the US military commissioned Bell Labs to develop a truly secure voice encryption system. The result was the Green Hornet, later adopted by the government as SIGSALY. A key innovation was the vocoder, which converted analog voice signals into digital data, enabling robust encryption. SIGSALY employed a one-time pad system: pairs of identical vinyl records were produced, one for each end of the communication. A record would encrypt the signal at one end and an exact clone would decrypt it at the other. Once used, the record was destroyed, ensuring perfect secrecy. SIGSALY was immensely successful, used for critical discussions like the bombing of Hiroshima, and remains uncracked to this day. However, its scale was immense—weighing over 50 tons and requiring 12 dedicated locations—making it impractical for widespread deployment.
Post-WWII, the need for scalable secure voice communication persisted. This led to the development of the AUTOSEVOCOM (Automated Secure Voice Communication Network) between 1955 and 1975. Devices like the KY3, weighing 300 pounds and costing approximately $18,000 per phone, integrated vocoders (e.g., the HY2) and encryption modules (e.g., the KG-13). Despite these advancements, a critical flaw remained in the key management. For any two phones (A and B) to communicate securely, each needed a copy of the other's encryption key. This "every phone needs every other phone's key" model meant that scaling the network was incredibly difficult; physical key devices could only hold a limited number of keys (around 299 per phone), severely restricting the number of possible secure connections. This cumbersome key distribution method became a major bottleneck.
The urgency of this problem escalated during the Vietnam War. The US military observed an alarming rate of battle losses, despite no apparent leaks of classified documents or codes. This led the NSA to launch Operation Purple Dragon to investigate. The findings were stark: the Vietnamese were not cracking codes, but rather meticulously observing OPSEC (Operational Security) failures. They monitored non-secret information such as radio usage patterns, call origins, supply chain movements, and changes in daily routines. By aggregating these seemingly innocuous data points, they could accurately predict US movements and counter them. This revelation spurred the DoD to prioritize fixing the device limit in encrypted communications, aiming for a system where any person in the DoD could call anyone else on an encrypted device. This was the crucible in which the concept of centralized authentication—the precursor to SSO—was forged.
Key Findings
▶ Watch: Bellfield system: Centralized keys, first SSO concept (10:30)
Connor Peshek's talk reveals several key findings that fundamentally reshape our understanding of Single Sign-On:
- The Bellfield System as the First SSO: Peshek posits that the Bellfield system, conceived by the head of R&D at the NSA during the Vietnam War, was the first true implementation of Single Sign-On. Its core innovation was replacing the N*N key distribution model with a central server holding all network keys. Once a device authenticated with this central server, it could establish trusted, encrypted communications with any other device on the network, effectively "signing on once" to gain access to multiple resources.
- Military Origins of Core Security Concepts: The talk powerfully demonstrates how critical security concepts, often attributed to modern computing, were born from military necessity. From the vocoder and one-time pads of SIGSALY to the centralized key management of Bellfield, wartime demands for secure, scalable communication drove innovations that laid the groundwork for contemporary authentication. The focus on OPSEC during the Vietnam War also highlights the enduring importance of protecting metadata and non-secret information.
- Jerome Saltzer and the Kerberos Connection: Peshek reveals a fascinating, almost clandestine, link between the classified Bellfield system and the creation of Kerberos. Jerome Saltzer, an MIT professor working on Project Athena, encountered the Bellfield system while consulting for the NSA. Recognizing its potential for his project, he subtly guided his colleagues, Needham and Schroeder, to develop a similar protocol based on vaguely described aspects of Bellfield from a conference proceeding. This led directly to the Needham-Schroeder protocol and its first implementation, Kerberos, establishing the lineage from military to academic SSO.
- Evolution Driven by Technological Shifts: The history of SSO is shown to be a continuous adaptation to evolving technological landscapes. Kerberos addressed the needs of local computer networks, while the advent of the internet and web applications necessitated new protocols like SAML (leveraging XML) and later OAuth and OpenID Connect (leveraging JSON and modern web paradigms). Each iteration responded to new challenges, from distributed computing to the rise of web apps and the need for robust authorization alongside authentication.
- The Distinction Between Authentication and Authorization: The talk implicitly and explicitly highlights the critical difference between proving who you are (authentication) and what you're allowed to do (authorization). Early systems like Bellfield and Kerberos primarily focused on authentication and secure session establishment. The later evolution, particularly with original OpenID and eventually OAuth, specifically addressed the authorization problem, moving beyond simply logging in to managing granular permissions for third-party applications.
These findings underscore that SSO is not merely a modern convenience but a sophisticated solution with a rich, complex history rooted in urgent security challenges, driven by cross-pollination between military, academic, and commercial sectors.
Technical Deep Dive
▶ Watch: Kerberos: Bellfield's unclassified clone for MIT Athena (15:30)
The evolution of SSO, as detailed by Peshek, is a story of iterative technical solutions addressing increasingly complex communication and access control problems.
The earliest attempt at voice security, the A3 Scrambler, was a rudimentary analog device. It operated on the principle of frequency inversion, taking high-pitch frequencies and making them low, and vice versa. This simple scrambling, however, was easily reversed, offering minimal security.
A significant leap forward came with SIGSALY (also known as the Green Hornet). This system introduced the vocoder, which digitized analog voice signals, allowing for sophisticated encryption. The core of SIGSALY's security was its use of a one-time pad. A pair of identical vinyl records, pre-recorded with random noise, would be synchronized at both ends of the communication. One record would modulate the digital voice signal for encryption, and the corresponding record would demodulate it for decryption. Once used, the record was physically destroyed, ensuring the key was never reused. This provided theoretically unbreakable encryption, but the system's immense size (over 50 tons) and cost rendered it impractical for widespread deployment.
Post-WWII, the AUTOSEVOCOM network aimed for more deployable secure voice. Devices like the KY3 phone incorporated a HY2 vocoder and a KG-13 encryption unit. However, the key management scheme was a severe limitation. To establish a secure call between Phone A and Phone B, Phone A needed Phone B's key, and Phone B needed Phone A's key. This meant that every phone on the network had to store a copy of every other phone's key, leading to an N*N key distribution problem. These keys were stored on physical devices that plugged into the phones, limiting the network's scalability to only a few hundred connections at best.
The breakthrough, and arguably the birth of SSO, came with the Bellfield system during the Vietnam War. This protocol introduced a central server that held all the keys for every device on the network. The communication flow for establishing a secure call was as follows:
- Request: Phone A wants to call Phone B and sends a request to the central server.
- Session Key Generation: The central server generates a unique, temporary session key for this specific call.
- Key Distribution: The server then encrypts this session key twice: once with Phone A's unique key and once with Phone B's unique key. It sends both encrypted session keys back to Phone A.
- Session Key Exchange: Phone A decrypts its version of the session key. It then sends the still encrypted version of the session key (encrypted with Phone B's key) to Phone B.
- Decryption and Communication: Phone B decrypts its version of the session key. Now, both Phone A and Phone B possess the same, unencrypted session key. They can then use this session key to encrypt and decrypt their voice communications for the duration of the call.
This system meant that each phone only needed its own unique key and the ability to communicate with the central server, dramatically simplifying key management and allowing for scalable, authenticated, and secure communication across the network. The STU1 and later STU3 phones were implementations of the Bellfield system, eventually becoming smaller and more cost-effective.
The Bellfield system's concepts found their way into civilian computing via Jerome Saltzer and Project Athena at MIT. Saltzer, inspired by the classified Bellfield system, guided his colleagues Needham and Schroeder to develop a similar protocol for computer networks. This resulted in the Needham-Schroeder protocol, which was first implemented as Kerberos. Kerberos operates on a similar principle of centralized authentication but introduces a Ticket Granting Server (TGS). A user authenticates once with the Key Distribution Center (KDC), which then issues a Ticket Granting Ticket (TGT). This TGT can then be presented to the TGS to obtain service tickets for various network resources, allowing the user to access multiple services without re-authenticating. Kerberos is still widely used in local networks, particularly in Microsoft environments, but has strict requirements for time synchronization and is not inherently web-native. Project Athena itself was a pioneering effort, providing thin client machines where users could log in once and access shared services like data storage, instant messaging, and graphical user interfaces (e.g., X Windows), demonstrating the power of SSO in a networked environment.
With the rise of the internet in the late 1990s, a new need arose for corporate SSO across disparate web applications. Companies like Microsoft, Sun Microsystems, and IBM collaborated to establish standards, leading to XML and HTTP. This paved the way for SAML (Security Assertion Markup Language). SAML is designed for web-based SSO, using XML documents exchanged over HTTP. An Identity Provider (IDP) (e.g., the early Netegrity SiteMinder, or modern Active Directory/Okta) asserts a user's identity to a Service Provider (SP). The user authenticates with the IDP, which then issues an XML-based assertion to the SP, granting access.
The "browser wars" of the mid-90s, particularly Microsoft's "embrace, extend, extinguish" strategy against Netscape, brought further innovation. Microsoft's development of XML HTTP Request to power its web-based Outlook email application was revolutionary. This technology allowed web pages to fetch data in the background without requiring a full page reload, effectively giving birth to Ajax and modern interactive web applications. As web apps proliferated, the complexity of parsing XML became a pain point, leading to the adoption of JSON as a lighter-weight, JavaScript-native data format.
This shift created a new landscape where SAML, with its XML dependency, felt increasingly cumbersome. The original OpenID, created by Brad Fitzpatrick of LiveJournal in 2005, attempted to address identity verification for distributed platforms by allowing users to prove ownership of a URL. However, a more pressing web problem emerged: authorization. Users were commonly asked to provide their full credentials (e.g., Gmail username/password to Facebook) to grant third-party apps access to their data. This insecure practice led to the development of OAuth for delegated authorization, allowing users to grant limited access without sharing credentials. Building upon OAuth, OpenID Connect (OIDC) emerged as the modern standard for authentication and identity, providing a lightweight, JSON-based layer on top of OAuth to verify user identity. These protocols form the backbone of modern web SSO, combining robust authentication with granular authorization capabilities.
Demo / Proof of Concept
▶ Watch: OAuth/OpenID Connect: Modern web authorization and identity (26:30)
The talk by Connor Peshek is primarily a historical and conceptual overview, tracing the lineage of Single Sign-On from its origins to modern implementations. As such, it did not include a live demonstration or proof of concept of any of the discussed protocols or systems. The focus was on the narrative and the technical evolution rather than a practical, hands-on showcase.
Defensive Implications
▶ Watch: Q&A: Jerome Saltzer and classified Bellfield system (28:50)
The historical journey of Single Sign-On offers profound lessons for modern cybersecurity defenders:
- Centralized Trust is a Double-Edged Sword: From the Bellfield system's central server to Kerberos's KDC and modern Identity Providers (IDPs) like Okta or Active Directory, the core principle of SSO is centralized trust. This dramatically simplifies user experience and key management, but it also creates a single, high-value target for adversaries. Securing the IDP with the utmost rigor—including multi-factor authentication, robust access controls, continuous monitoring, and strong incident response plans—is paramount. A compromise of the IDP can lead to widespread organizational compromise.
- Operational Security (OPSEC) Remains Critical: The lessons from Operation Purple Dragon during the Vietnam War are timeless. Even if encryption is strong, adversaries can derive significant intelligence from analyzing non-secret information and metadata. Defenders must consider not just the content of communications but also patterns of activity, network traffic metadata (who talks to whom, when, how often), and observable changes in routine. A holistic approach to security, encompassing physical, human, and technical aspects, is essential to prevent such "side-channel" intelligence gathering.
- Key Management is Fundamental: The struggles with key distribution in the AUTOSEVOCOM network highlight the enduring importance of robust key management. Modern systems like Bellfield, Kerberos, SAML, and OIDC solve this through various mechanisms, but the underlying principle remains: keys must be securely generated, stored, distributed, rotated, and revoked. Compromised keys, regardless of the protocol, undermine the entire security posture. Defenders must implement automated key rotation, secure key storage (e.g., HSMs), and strict access policies for cryptographic material.
- Understand Protocol Nuances and Limitations: Each SSO protocol (Kerberos, SAML, OAuth, OIDC) has specific strengths, weaknesses, and ideal use cases. Kerberos, for instance, requires strict time synchronization and is primarily for local networks, while SAML is XML-heavy and better suited for enterprise-to-enterprise federation. OAuth and OIDC are the modern choice for web and mobile applications, distinguishing between authorization (what an app can do) and authentication (who the user is). Defenders must choose the appropriate protocol for their environment and understand its specific security considerations and configuration best practices.
- Authorization vs. Authentication is Key: The evolution from early SSO to modern OAuth/OIDC clearly delineates the concepts of authentication (verifying identity) and authorization (granting permissions). Defenders must ensure that their systems not only verify who a user is but also precisely control what that user (or an application acting on their behalf) is allowed to access or do. Overly broad permissions or a lack of granular authorization can lead to privilege escalation and data breaches, even if authentication is strong.
- The Supply Chain of Trust: When integrating third-party services or applications using SSO, organizations extend their trust boundary. The security of the IDP is paramount, but so is the security posture of every service provider that relies on it. Defenders must vet third-party vendors, ensure they adhere to security best practices, and understand the implications of granting them access to user identities or resources through SSO protocols.
In essence, the history of SSO teaches us that robust security is a continuous process of adaptation, recognizing that yesterday's solutions may become today's vulnerabilities, and that fundamental principles like centralized trust, key management, and operational security remain at the core of effective defense.
Key Takeaways
- SSO's Military Origins: The fundamental principles of Single Sign-On (SSO) emerged from urgent military needs for secure and scalable communication during World War II and the Vietnam War, particularly with the development of the Bellfield system.
- Centralized Trust as a Breakthrough: The Bellfield system's innovation of a central server managing all encryption keys for a network of devices solved the previous N*N key distribution problem, allowing for scalable, authenticated, and secure communication, marking it as arguably the first SSO system.
- From Classified to Open Source: The classified Bellfield system directly influenced the development of Kerberos at MIT through Jerome Saltzer, demonstrating a crucial transfer of military security concepts into academic and eventually commercial computing.
- Adaptation to Technological Eras: SSO protocols have continuously evolved to meet the demands of changing technological landscapes, from local computer networks (Kerberos) to the early internet (SAML with XML) and modern web applications (OAuth and OpenID Connect with JSON).
- The Importance of OPSEC: The lessons from Operation Purple Dragon during the Vietnam War highlight that even without code-breaking, adversaries can gain significant intelligence by analyzing non-secret information and operational patterns, underscoring the enduring relevance of strong Operational Security.
- Securing the IDP is Paramount: Modern SSO systems rely heavily on a centralized Identity Provider (IDP). While offering convenience and scalability, this centralization makes the IDP a critical target, emphasizing the need for stringent security measures around it.
About the Speaker(s)
Connor Peshek is a self-taught JavaScript engineer with a diverse background in software development and developer relations. He began his career at Kroger, where he contributed to the early development of their online grocery ordering system, Clicklist, back in 2017. Following this, he co-founded a startup that was later acquired by Cloudflare, where he spent three and a half years primarily working in DevRel. Currently, Connor works at Authentic, a company that provides an open-source, self-hostable alternative to commercial identity providers like Okta. In his role at Authentic, he splits his time between backend engineering and DevRel responsibilities. His interest in the history of single sign-on protocols was sparked by his extensive research in the authentication space, leading him to discover the surprisingly rich and compelling origins of SSO.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Peshek delivers a neat historical deep-dive tracing modern SSO back to NSA Vietnam War crypto, but it's entirely narrative. There is zero technical payload here for anyone building or breaking modern identity providers. It fills a CypherCon slot fine as a campfire story, but it absolutely should have been a blog post.
Heather Calloway (CISO) — SOLID
This is an engaging history lesson on the military origins of SSO, tracing the lineage from Vietnam-era voice encryption to modern OIDC. While intellectually interesting for identity engineers, it contains no new operational takeaways or strategic imperatives for a modern security program. It's good edutainment, but your leadership team can skip it.