The History of Authentication

Matt George

Fractional CTO · Founder of Injuria.ai

•20 min read•

The History of Authentication

Authentication in computing is the process of verifying that an entity, whether a human user or a machine process, is who it claims to be. The history of this discipline is defined by a continuous arms race between the mechanisms designed to protect systems and the adversaries seeking to compromise them. Early computing environments relied entirely on physical security, where access to a machine room was sufficient proof of authorization. As computers became time-shared and networked, physical proximity was no longer a viable proxy for identity, forcing the development of logical access controls.

The technical evolution of authentication reflects shifting constraints in storage, computation, and network topology. In the 1960s, expensive mainframe time required simple shared secrets to partition user files. By the 1980s, the proliferation of local area networks exposed plaintext credentials to wiretapping, driving the adoption of symmetric-key cryptographic protocols and directory services. The explosion of the World Wide Web in the 1990s introduced the challenge of maintaining stateful identity over stateless protocols, leading to the invention of HTTP cookies and transport-layer encryption. In the 21st century, the sheer volume of web services caused password fatigue and widespread credential reuse, which necessitated federated identity standards and delegated authorization frameworks.

Today, the perimeter-based security models of the past have collapsed under the weight of cloud computing and mobile devices.[19] Modern authentication relies on public-key cryptography, hardware-backed biometric sensors, and continuous risk assessment. The fundamental tradeoff between security and usability remains, but contemporary standards attempt to resolve this tension by removing shared secrets from the authentication exchange entirely.

Pre-Computing and Early Physical Security

Before the advent of logical access controls, authentication was a physical discipline. For centuries, verifying identity relied on physical tokens, such as wax seals and signet rings, or shared knowledge, such as military passcodes. When the first electronic computers were constructed in the 1940s and 1950s, they were massive, fragile machines housed in secure government or university facilities. Authentication to systems like the ENIAC or the UNIVAC I consisted of armed guards, locked doors, and authorized operator badges. If a person was physically standing at the control panel, the system implicitly trusted them.

This physical paradigm began to strain during the Cold War with the development of the Semi-Automatic Ground Environment (SAGE) system. Commissioned by the United States military in the 1950s to monitor airspace for Soviet bombers, SAGE was one of the first wide-area computer networks. It connected radar stations to centralized IBM AN/FSQ-7 computers. Because SAGE required hundreds of operators sitting at remote display consoles using light guns and cathode-ray tubes, physical room security was insufficient to track individual actions. The military implemented strict procedural authentication, requiring operators to use physical badges and specific terminal login procedures to track who was issuing commands that could potentially scramble interceptor jets. SAGE demonstrated that as systems became distributed, the computer itself needed a mechanism to identify the human at the terminal.

The Mainframe Era and the First Passwords

In the early days of commercial computing, machines processed jobs in batches. Users handed punch cards to an operator and waited for the printed results. Security remained primarily physical. This changed with the advent of time-sharing systems, which allowed multiple users to interact with a single mainframe simultaneously via remote teleprinters. CTSS was initially developed and demonstrated on an IBM 709 computer in 1961 (it was not moved to the IBM 7094 until 1962/1963). Fernando Corbató, the lead developer of CTSS, introduced the concept of the computer password to partition user files and allocate processing time. Each user was assigned a private account and a secret string of characters.

The vulnerabilities of plaintext passwords became apparent almost immediately. Allan Scherr printed out the CTSS password file in 1962, not 1965. Scherr used the stolen credentials to log into the accounts of other users, including Corbató, to allocate more computing time for his own simulation work. A subsequent software bug in 1966 caused the CTSS system to accidentally swap the password file with the daily welcome message, displaying every user's password on the terminal screens of anyone who logged in. These incidents demonstrated that storing passwords in plaintext created a single point of failure.

The successor to CTSS was Multics (Multiplexed Information and Computing Service), a highly influential operating system developed jointly by MIT, Bell Labs, and General Electric starting in 1964. Multics was designed with security as a foundational requirement. It introduced a hierarchical file system, ring-based security, and Access Control Lists (ACLs). The Cambridge University Titan system was the first to hash passwords (invented by Roger Needham and Mike Guy), not Multics, ensuring that a compromised password file would not immediately yield plaintext credentials.

Commercial mainframe vendors soon followed suit. In 1976, IBM introduced the Resource Access Control Facility (RACF) for its MVS operating system. RACF provided a centralized mechanism to identify and authenticate users, log their access attempts, and enforce access control lists across the mainframe environment. RACF formalized the concept of the user ID and password combination as the standard for corporate computing.

Unix and the Cryptographic Foundation

While Multics pioneered password hashing, the technique was refined and popularized in the 1970s with the development of the Unix operating system at Bell Labs. Robert Morris and Ken Thompson recognized that the operating system needed to verify a password without actually storing it. In their 1979 paper "Password Security: A Case History,"[1] published in the Communications of the ACM, Morris and Thompson detailed the Unix crypt function. Instead of storing the plaintext password, the system passed the user's input through a one-way cryptographic hash function based on a modified Data Encryption Standard (DES) algorithm. The system stored only the resulting hash. When a user attempted to log in, the system hashed the provided password and compared it to the stored hash.

Morris and Thompson also introduced the concept of a cryptographic "salt." A salt is a random 12-bit number generated when the password is created and appended to the plaintext before hashing. The salt is stored in plaintext alongside the hash. This technique solved two problems. First, it ensured that two users with the exact same password would have different hashes, preventing an attacker from identifying common passwords by scanning the file. Second, it forced attackers to compute a separate dictionary of hashes for every possible salt value (4096 variations in early Unix), drastically increasing the computational cost of a dictionary attack. Despite these defenses, the Morris and Thompson paper noted that users consistently chose weak, easily guessable passwords, a human factors problem that would persist for decades.

The 1970s also saw a theoretical breakthrough that would eventually revolutionize authentication. In November 1976, Whitfield Diffie and Martin Hellman published "New Directions in Cryptography"[2] in the IEEE Transactions on Information Theory. Prior to this paper, all cryptography was symmetric, meaning the sender and receiver had to possess the same secret key. Diffie and Hellman introduced the concept of asymmetric, or public-key, cryptography. In this model, a user generates a mathematically linked pair of keys: a public key that can be shared openly, and a private key that is kept secret. Data encrypted with the public key can only be decrypted by the private key, and data signed by the private key can be verified by the public key.[20] While British intelligence agency GCHQ had secretly discovered similar concepts a few years earlier, the Diffie and Hellman publication provided the public mathematical foundation for digital signatures and secure key exchange, which are the basis of all modern authentication protocols.

Networked Computing and Directory Services

As computing moved from centralized mainframes to distributed networks of workstations in the 1980s, the Unix crypt model became insufficient. On a local area network (LAN), authentication requests traveled over shared Ethernet cables. An attacker with a packet sniffer could easily intercept plaintext passwords as they were transmitted from a terminal to a server.

To address this, MIT launched Project Athena in 1983 to build a distributed computing environment for its campus. A strict requirement was a secure authentication system that did not transmit passwords over the network. The result was the Kerberos protocol[3], named after the three-headed dog of Greek mythology. Developed primarily by Steve Miller and Clifford Neuman, Kerberos was based on the Needham-Schroeder symmetric key protocol.

Kerberos introduced a trusted third party known as the Key Distribution Center (KDC). The KDC shares a unique secret symmetric key with every user and every service on the network. When a user logs in, the client software does not send the password to the KDC. Instead, the client sends a plaintext request for a Ticket-Granting Ticket (TGT). The KDC generates a TGT, encrypts it with the user's secret key (derived from their password), and sends it back. If the user knows their password, their client software can decrypt the TGT.

The TGT acts as a temporary credential. When the user wants to access a specific service, such as a file server or a printer, the client presents the TGT to the KDC and requests a service ticket. The KDC issues a service ticket encrypted with the target service's secret key. The client then forwards this ticket to the service. Because the service ticket is encrypted with the service's key, the service can decrypt it, verify the KDC's signature, and grant access. This architecture ensures that passwords never traverse the network. Kerberos Version 5 was standardized by the Internet Engineering Task Force (IETF) in 1993 under RFC 1510[4]. Microsoft later adopted Kerberos as the default authentication protocol for Active Directory in Windows 2000, cementing its role in corporate networks worldwide.

Simultaneously, the telecommunications industry was standardizing identity. In 1988, the International Telecommunication Union (ITU-T) published the X.509 standard[5], which defined a strict format for public-key certificates. An X.509 certificate binds a cryptographic public key to a specific identity (such as a person or a server) using a digital signature from a trusted Certificate Authority (CA). This standard became the basis for Public Key Infrastructure (PKI).

Managing these identities required specialized databases. In 1997, the IETF published RFC 2251[6], defining the Lightweight Directory Access Protocol (LDAP) version 3. LDAP provided a standardized mechanism for querying and modifying directory services over an IP network, allowing organizations to maintain a single, centralized repository of user accounts.[21] For remote access, the Remote Authentication Dial-In User Service (RADIUS) protocol, standardized in RFC 2865[7] (obsoleting RFC 2138), provided centralized authentication, authorization, and accounting for users connecting via dial-up modems and later virtual private networks (VPNs).

The World Wide Web and HTTP Authentication

The invention of the World Wide Web in 1989 introduced a new architectural constraint: the Hypertext Transfer Protocol (HTTP) is inherently stateless. A web server treats every request as an independent transaction, retaining no memory of previous requests. This statelessness made it difficult to restrict access to specific web pages.

In 1993, Ari Luotonen at CERN implemented Basic Access Authentication, which was later standardized in 1996 under RFC 1945[8] (HTTP/1.0). In the Basic Authentication scheme, when a client requests a protected resource, the server responds with a 401 Unauthorized status code and a WWW-Authenticate header. The browser then prompts the user for a username and password. The browser concatenates the username and password with a colon, encodes the string using Base64, and sends it back to the server in an Authorization header.

Basic Authentication was simple to implement, but it suffered from a severe security flaw. Base64 is an encoding scheme, not encryption. Anyone intercepting the HTTP traffic could easily decode the header and recover the plaintext credentials. In addition, because HTTP is stateless, the browser had to send the Authorization header with every single request to maintain access, multiplying the opportunities for interception. Early proprietary protocols like Microsoft's NTLM (New Technology LAN Manager) attempted to provide challenge-response authentication over HTTP, but the broader security of web authentication was only salvaged by the introduction of the Secure Sockets Layer (SSL) protocol by Netscape Communications in 1994, which provided an encrypted tunnel between the browser and the server.

However, sending credentials with every request remained inefficient and limited the user experience. Web developers needed a way to authenticate a user once and maintain a session. In June 1994, Lou Montulli[9], a 23-year-old engineer at Netscape, invented the HTTP cookie. Montulli was building an e-commerce application for MCI and needed a way to implement a virtual shopping cart without requiring the server to store the state of every visitor.

Montulli's solution allowed the server to send a small piece of data (a "magic cookie") to the browser in a Set-Cookie header. The browser would store this data and send it back to the server in a Cookie header on subsequent requests. With cookies, a server could verify a user's password once, generate a unique, cryptographically secure session identifier, and send that identifier to the browser as a cookie. For the duration of the session, the browser presented the cookie instead of the password. Version 0.9beta of Mosaic Netscape, released on October 13, 1994, was the first browser to support cookies. This mechanism remains the foundation of web session management today.

Federation, Single Sign-On, and Delegated Access

By the early 2000s, the proliferation of web applications created a new problem: password fatigue. Users were forced to create and remember dozens of different usernames and passwords. This led to widespread credential reuse, where a breach at a low-security forum could compromise a user's high-security banking or email account.

The enterprise software industry responded by developing Single Sign-On (SSO) protocols. In November 2002, the Organization for the Advancement of Structured Information Standards (OASIS) approved the Security Assertion Markup Language (SAML) 1.0[10]. SAML is an XML-based framework that allows an Identity Provider (IdP) to pass authorization credentials to a Service Provider (SP). When an employee attempts to access a cloud-based human resources application, the application redirects the user to the corporate IdP. The user authenticates with the IdP, which then generates an XML document (a SAML assertion) cryptographically signed by the IdP. The browser forwards this assertion to the HR application, which verifies the signature and grants access. SAML decoupled the authentication mechanism from the application, allowing organizations to manage identities centrally.

Around the same time, the academic and research community developed Shibboleth, an open-source project based on SAML that allowed students to access resources across different universities using their home institution's credentials. Yale University also developed the Central Authentication Service (CAS), another early and influential web SSO protocol. These projects demonstrated the viability of cross-domain identity federation.

While SAML solved SSO for the enterprise, its heavy reliance on XML and complex trust relationships made it unsuitable for the consumer web. In 2005, Brad Fitzpatrick developed OpenID, a decentralized protocol that allowed users to log into multiple websites using a single URI controlled by an OpenID provider.

Simultaneously, the rise of social media and third-party web APIs created a need for delegated authorization. If a user wanted a photo-printing service to access their Flickr account, the only method available was to give the printing service their Flickr username and password. This violated the principle of least privilege.

In 2007, developers from Twitter and Ma.gnolia began working on an open protocol to solve this problem, resulting in OAuth. The IETF standardized the OAuth 2.0 authorization framework in 2012 under RFC 6749[11]. OAuth 2.0 allows a user to grant a third-party application limited access to an HTTP service without sharing their credentials. Instead of a password, the application receives an access token.

OAuth 2.0 was designed strictly for authorization, not authentication. It provided a way to access data, but it did not provide a standardized way for the client application to know the identity of the user. Developers frequently misused OAuth 2.0 for authentication, leading to security vulnerabilities. To correct this, the OpenID Foundation published OpenID Connect (OIDC)[12] in 2014. OIDC is a simple identity layer built on top of the OAuth 2.0 protocol. It introduces an "ID Token" formatted as a JSON Web Token (JWT), which contains claims about the authenticated user. The combination of OAuth 2.0 and OIDC powers the ubiquitous login buttons that centralize consumer identity into a handful of massive technology companies.

The Rise of Multi-Factor and Hardware Authentication

As computing power increased, brute-force and dictionary attacks against hashed passwords became trivial. The widespread use of phishing allowed attackers to bypass cryptographic defenses entirely by simply tricking users into handing over their credentials. It became clear that single-factor authentication (relying solely on something the user knows) was inadequate.

Multi-factor authentication (MFA) requires the user to present two or more independent pieces of evidence: something they know (a password), something they have (a physical token or mobile device), or something they are (a biometric characteristic).

The commercialization of hardware tokens began in 1984 when Kenneth P. Weiss[13] founded Security Dynamics. Weiss invented the SecurID card, a physical token with an LCD screen that displayed a new numeric code every 60 seconds. The token contained a microprocessor, a battery, a clock, and a secret cryptographic seed. The authentication server held a copy of the same seed. When the user logged in, they provided their password and the current number displayed on the token. The server calculated the expected number based on the shared seed and the current time. If the numbers matched, access was granted. Security Dynamics acquired RSA Data Security in July 1996, and the RSA SecurID token became a staple of corporate VPN access.

Governments also drove the adoption of hardware authentication. In August 2004, the United States government issued Homeland Security Presidential Directive 12 (HSPD-12), mandating a common identification standard for federal employees. The National Institute of Standards and Technology (NIST) responded by publishing Federal Information Processing Standard (FIPS) 201[14], which defined the Personal Identity Verification (PIV) card. The PIV card, along with the Department of Defense's Common Access Card (CAC), utilizes an embedded microchip to store X.509 certificates and perform cryptographic operations, requiring the user to possess the physical card and know a Personal Identification Number (PIN).

Hardware tokens were expensive to distribute and maintain. The proliferation of mobile phones in the 2000s offered a cheaper alternative: delivering one-time passwords via Short Message Service (SMS).[19] While SMS OTPs improved security over passwords alone, they were vulnerable to SIM swapping attacks and interception over the unencrypted Signaling System 7 (SS7) telecommunications network.[22]

To provide a secure, software-based alternative, the IETF standardized the Time-Based One-Time Password (TOTP) algorithm in 2011 under RFC 6238[15]. TOTP is an extension of the HMAC-based One-Time Password (HOTP) algorithm (RFC 4226). In a TOTP system, the server generates a base32-encoded secret key, often displayed to the user as a QR code. The user scans the QR code with an authenticator application, such as Google Authenticator or Authy. Both the server and the application use the shared secret and the current Unix time to independently compute a six-digit code using a cryptographic hash function (typically HMAC-SHA1). Because the computation is done locally on the device, TOTP does not require a network connection and is immune to SMS interception.

However, TOTP codes can still be stolen via real-time phishing proxies. To eliminate phishing entirely, a consortium of companies including Lenovo, PayPal, and Yubico formed the FIDO (Fast Identity Online) Alliance in 2012. The FIDO Alliance developed the Universal 2nd Factor (U2F) protocol, which relies on public-key cryptography. When a user registers a U2F security key (such as a YubiKey), the device generates a new public-private key pair. The public key is sent to the server, while the private key never leaves the secure element of the hardware token. During authentication, the server sends a cryptographic challenge. The user physically touches the security key, which signs the challenge with the private key and returns it. Because the browser binds the signature to the specific domain name of the website, a U2F token will refuse to sign a challenge from a fake phishing domain.

The Modern State: Passwordless and Zero Trust

The success of the FIDO Alliance's hardware protocols led to a collaboration with the World Wide Web Consortium (W3C) to bring public-key authentication directly into web browsers. In March 2019, the W3C published the Web Authentication (WebAuthn)[16] specification as an official web standard. WebAuthn provides a standardized JavaScript API that allows web applications to create and use strong, attested, public-key-based credentials.

WebAuthn forms the core of the FIDO2 project, which aims to eliminate passwords entirely. Under FIDO2, the user's device (a smartphone or laptop) acts as the authenticator. Instead of typing a password, the user unlocks their device using a local biometric sensor, such as Apple's Touch ID (introduced in 2013) or Face ID (2017), or Microsoft's Windows Hello. The biometric data never leaves the device; it simply unlocks the private key stored in the device's secure enclave, which then signs the WebAuthn challenge.

In 2022, Apple, Google, and Microsoft announced expanded support for the FIDO standard through a concept called "passkeys." Historically, FIDO credentials were bound to a single physical device. If the device was lost, the user lost access to their accounts. Passkeys are discoverable FIDO credentials that are end-to-end encrypted and synchronized across a user's devices via cloud ecosystems (such as iCloud Keychain or Google Password Manager). Passkeys represent a fundamental shift in authentication architecture: they replace the shared secret of a password with a synchronized private key, offering the security of hardware tokens with the usability of a password manager.

As the technology of authentication evolved, so did the regulatory and conceptual frameworks governing it. In 2017, NIST published a major revision to its Special Publication 800-63 Digital Identity Guidelines[17]. This document fundamentally altered industry best practices by deprecating arbitrary password complexity rules and mandatory expiration policies, which research showed actually degraded security by encouraging users to choose predictable patterns. In addition, SP 800-63 formalized the concept of Authenticator Assurance Levels (AAL), providing a rigorous framework for evaluating the strength of different authentication mechanisms, and explicitly warned against the use of SMS for two-factor authentication due to interception risks.

Simultaneously, the conceptual framework surrounding network security underwent a radical revision. For decades, network security relied on a perimeter model: firewalls kept attackers out, and anyone inside the corporate network was implicitly trusted. The shift to remote work, cloud infrastructure, and Bring Your Own Device (BYOD) policies rendered the physical network perimeter obsolete.

In August 2020, NIST published Special Publication 800-207[18], formally defining Zero Trust Architecture (ZTA). The core tenet of Zero Trust is "never trust, always verify." Under this model, no implicit trust is granted to an asset or user account based solely on its physical or network location.

In a Zero Trust environment, authentication is no longer a binary, one-time gate at the edge of a network. Instead, authentication and authorization are discrete functions performed continuously.[23] A Policy Decision Point (PDP) evaluates every access request dynamically, considering the user's identity, the device's security posture, the geographic location, and the time of day. If a user successfully authenticates with a passkey but attempts to download a sensitive database from an unrecognized IP address, the system may demand step-up authentication or block the request entirely.

The history of authentication has moved from protecting physical mainframes with simple strings of text to securing distributed cloud resources with synchronized cryptographic keys and continuous behavioral analysis. The modern state of authentication acknowledges that networks are inherently hostile and that human users cannot be trusted to generate or manage secrets. By shifting the cryptographic burden to hardware enclaves and automated protocols, the industry is closing the vulnerabilities introduced by Fernando Corbató's first password file in 1961.

Sources (23)
  1. ACM Digital Library
  2. IEEE
  3. IEEE
  4. IETF
  5. X.509 standard
  6. IETF
  7. IETF
  8. IETF
  9. Lou Montulli
  10. Security Assertion Markup Language (SAML) 1.0
  11. IETF
  12. OpenID Connect (OIDC)
  13. Kenneth P. Weiss
  14. Federal Information Processing Standard (FIPS) 201
  15. IETF
  16. W3C
  17. Special Publication 800-63 Digital Identity Guidelines
  18. Special Publication 800-207
  19. Natarajan Meghanathan, Selma Boumerdassi, Nabendu Chaki, Recent Trends in Network Security and Applications (Springer Science & Business Media, 2010)
  20. Mohsen A. M. El-Bendary, Developing Security Tools of WSN and WBAN Networks Applications (Springer, 2014)
  21. Tag G. Kim, Artificial Intelligence and Simulation (Springer Science & Business Media, 2005)
  22. Nikita Borisov, Claudia Diaz, Financial Cryptography and Data Security (Springer Nature, 2021)
  23. Nathan Clarke, Transparent User Authentication (Springer Science & Business Media, 2011)

Recommended reading