{
  "id": "authentication",
  "title": "Authentication",
  "lang": "en",
  "source_lang": "en",
  "summary": "Authentication establishes confidence in a claimed identity or the origin of data through credentials, protocols, and verification procedures.",
  "category": "computer-science",
  "subcategory": "networks-security",
  "type": "concept",
  "aliases": [
    "Identity authentication",
    "digital authentication"
  ],
  "generated_at": "2026-11-05",
  "model": "pro/gpt-6.1-sol",
  "url": "https://aiwiki.page/en/authentication/",
  "translations": {
    "zh-Hans": {
      "url": "https://aiwiki.page/zh/authentication/",
      "json": "https://aiwiki.page/zh/authentication.json"
    }
  },
  "sections": [
    {
      "heading": "",
      "text": "Authentication is the process of establishing confidence that an entity is the one it claims to be, or that information originates from a claimed source. In computing, the entity may be a person, device, software process, service, or organization. Authentication commonly establishes that a claimant controls a credential associated with an account; it does not necessarily establish the claimant’s legal identity. A pseudonymous account can therefore be authenticated without identifying the person who operates it.\n\nAuthentication is a central function of cybersecurity because systems must distinguish legitimate participants from impersonators before granting access, accepting commands, or exchanging sensitive information. It supports activities ranging from signing into a website to verifying a software update or establishing an encrypted connection between servers. Its reliability depends not only on the mathematical strength of a protocol but also on enrollment, credential storage, device security, recovery procedures, and the handling of authenticated sessions.\n\nTwo related meanings are important. Entity authentication concerns the identity of a participant, often with evidence that the participant is currently involved in a protocol. Data-origin authentication concerns the source of a message or other data. The latter does not, by itself, establish that the source is presently online or that a message is new. Both meanings draw heavily on cryptography, but their security objectives and mechanisms differ."
    },
    {
      "heading": "Identity, authentication, and authorization",
      "text": "Authentication begins with a claim. A username, account number, device identifier, or certificate subject identifies the entity that a claimant purports to represent. Such an identifier is not normally secret and is not itself proof of identity. The verifier evaluates additional evidence, such as knowledge of a password or possession of a private key, according to an authentication protocol. The result is a decision made within a particular trust relationship, rather than an unconditional statement about a person.\n\nIdentification, authentication, and authorization answer different questions. Identification specifies which entity is being claimed. Authentication evaluates the evidence supporting that claim. Authorization determines which actions the authenticated entity may perform. Within access control, these functions are often connected, but they are not interchangeable. A successfully authenticated employee may still lack permission to read payroll records. Conversely, a public information service may authorize anonymous reading without authenticating its visitors.\n\nIdentity proofing is another distinct activity. It connects a digital account to evidence about a person or organization outside the system, potentially using identity documents, organizational records, or an in-person examination. Authentication subsequently demonstrates control of credentials associated with that account. A service can have strong authentication and weak identity proofing: a cryptographic key may reliably identify the same account holder on successive visits even though the account was created using false personal details. The reverse is also possible when a carefully verified identity is protected only by an easily guessed password.\n\nThe meaning of successful authentication depends on the threat model. A password check establishes that the claimant supplied a matching secret, not that the legitimate user personally typed it. A device certificate establishes control of a corresponding private key, subject to the assumptions of the certificate system and key storage. Neither necessarily proves that the endpoint is free of malware, that the user understands a transaction, or that the requested operation is appropriate.\n\nAuthentication may be unilateral or mutual. In unilateral authentication, one participant proves an identity to another. In mutual authentication, both participants obtain evidence about their peer. A banking website typically authenticates itself to a browser through a server certificate before authenticating the customer through a separate login process. These are different protocol events with different credentials. Authentication also has a temporal boundary: evidence accepted at login does not establish continuous control of an account indefinitely. Systems therefore combine initial authentication with session expiration, reauthentication, and checks for changes in relevant conditions."
    },
    {
      "heading": "Enrollment, credentials, and account recovery",
      "text": "An authentication system has a lifecycle extending beyond the moment of login. Enrollment creates an account or identity record and binds one or more authenticators to it. An authenticator is something the claimant controls and uses to produce authentication evidence. A credential records or represents the binding between an identity and an authenticator. Terminology varies across standards and implementations: “credential” may refer to a certificate, a password record, a public-key registration, or an access token.\n\nThe initial binding is a critical trust decision. Registering a hardware security key after an existing authenticated session transfers some of that session’s trust to the new key. Registering the same key through an account-recovery process transfers trust from the recovery evidence instead. If an attacker can add a new authenticator using only access to a weak recovery channel, the strength of the primary authenticator does not prevent account takeover. Administrative resets, customer-support procedures, and changes to recovery addresses therefore form part of the authentication boundary.\n\nCredentials require maintenance. Passwords may need replacement after exposure; certificates expire; devices are lost; employees change roles or leave organizations. Revocation withdraws acceptance before a credential would otherwise cease to be valid. Its effectiveness depends on how quickly verifiers learn of the change and whether already established sessions remain usable. Deleting a public key from an account, for example, prevents new authentications with that key but does not automatically invalidate every session previously created through it.\n\nRecovery mechanisms include backup authenticators, one-use recovery codes, identity reproofing, and intervention by an authorized administrator. Each changes the system’s security and availability properties. A recovery code is typically a high-entropy secret intended for limited use, whereas personal questions often rely on information that acquaintances, public records, or social media can reveal. A recovery process must also distinguish recovering access to an existing account from creating a new identity with similar attributes.\n\nOperational records support investigation and accountability. Authentication logs can record successful and failed attempts, authenticator registration, recovery events, source addresses, and session termination. Such records are useful only if protected against unauthorized modification and interpreted carefully: a successful authentication is evidence that the mechanism accepted a claim, not conclusive evidence that a particular person acted. Logs themselves can expose sensitive information about location, work patterns, and account relationships.\n\nLifecycle design also involves continuity. An organization may need to replace a compromised credential without changing the account’s identifier, permissions, or audit history. Conversely, reassigning an old username must not silently transfer the former holder’s credentials or privileges to a new person. Keeping identities, authenticators, and authorization records conceptually separate helps explain these otherwise subtle failure modes."
    },
    {
      "heading": "Passwords and shared-secret verification",
      "text": "Passwords are reusable secrets shared, directly or indirectly, between a claimant and a verifier. They became a familiar component of interactive computing through early time-sharing systems; MIT’s Compatible Time-Sharing System, introduced in 1961, was an influential early example. Passwords remain widely deployed because they require little specialized equipment and work across many interfaces. Their limitations arise chiefly from human selection, reuse, disclosure, and the consequences of centralized verification data.\n\nA password verifier should not need to store the password in plaintext. Instead, it can store a value derived from the password using a deliberately expensive password-hashing function and a random salt. In simplified notation,\n\n\\[v=\\operatorname{KDF}(P,s;\\theta),\\]\n\nwhere \\(P\\) is the password, \\(s\\) is the salt, and \\(\\theta\\) denotes parameters controlling computational or memory cost. At login, the verifier applies the same derivation to the submitted password and compares the result with \\(v\\). A salt is not a secret; it prevents identical passwords from necessarily producing identical stored values and limits the usefulness of precomputed tables.\n\nAn ordinary fast cryptographic hash function is not, by itself, an adequate password-storage mechanism. Attackers who obtain a password database can test guesses offline without interacting with the original service. Password-hashing schemes such as bcrypt, scrypt, and Argon2 increase the cost of these guesses. Argon2 won the Password Hashing Competition in 2015; its variants combine configurable memory and computation costs. Such mechanisms slow guessing but do not transform a predictable password into a high-entropy secret.\n\nOnline and offline guessing are different threats. Online attacks can be constrained by rate limits and other server-side controls. Offline attacks against stolen verification records are limited primarily by the attacker’s resources and the password-derivation cost. Strict account lockout can impede guessing but can also enable a denial-of-service attack when an adversary deliberately triggers lockouts for other users.\n\nCredential stuffing exploits passwords disclosed by one service against accounts at another. Password spraying tests a small set of common passwords across many accounts, often avoiding per-account thresholds. These attacks differ from exhaustive search because they exploit predictable human behavior and password reuse. A password manager can generate and retain distinct secrets, although its security then depends on its own authentication, storage, and endpoint protections.\n\nPasswords sent through a protected connection remain vulnerable to deceptive endpoints. Transport Layer Security protects traffic between the endpoints of a connection, but an impostor website can establish its own valid encrypted connection and collect a victim’s password. More specialized password-authenticated key-exchange protocols can establish cryptographic keys from a shared password without simply transmitting it. Their guarantees depend on the particular protocol and do not eliminate every risk associated with a compromised client or deceptive user interface."
    },
    {
      "heading": "Authentication factors, biometrics, and passkeys",
      "text": "Authentication factors are commonly grouped as something a claimant knows, possesses, or is. A password is a knowledge factor; a security key or cryptographic device is a possession factor; a fingerprint or facial characteristic is an inherence factor. Multifactor authentication combines factors from different categories. Two passwords do not normally constitute two-factor authentication, and two steps in an interface do not necessarily represent independent security factors.\n\nPossession can be demonstrated in several ways. A hardware token may display a one-time code, or a device may sign a challenge using a protected key. The HMAC-based One-Time Password algorithm, standardized in RFC 4226 in 2005, derives codes from a shared secret and counter. The Time-Based One-Time Password algorithm, standardized in RFC 6238 in 2011, instead uses a value derived from time. A verifier usually accepts a limited time window to accommodate clock differences. These codes reduce the usefulness of recording an old login, but an attacker can sometimes relay a current code to the genuine service.\n\nBiometric systems compare a fresh measurement with an enrolled template. Because repeated measurements differ, comparison uses a threshold rather than exact equality. False-match and false-nonmatch rates describe different errors, and changing the threshold typically trades one against the other. Performance also depends on capture conditions, sensors, populations, and presentation attacks, such as an artificial fingerprint or an image placed before a camera. A measured error rate is meaningful only in the context of the evaluation procedure.\n\nBiometrics have distinctive lifecycle properties. They are not secrets in the same sense as randomly generated keys, and many characteristics cannot readily be replaced after exposure. In many modern devices, a biometric match occurs locally and authorizes use of a cryptographic key; the remote service receives a signature rather than a fingerprint image or facial template. This separates local user verification from remote authentication and limits the biometric information disclosed to the service.\n\nPasskeys are public-key credentials designed for use through FIDO authentication protocols. A service registers a public key, while the corresponding private key is controlled through an authenticator. A login uses a fresh challenge and produces evidence bound to the relevant service. A passkey may be device-bound or made available across a user’s devices through a credential provider’s synchronization system. These models have different recovery and trust properties.\n\nFactor independence is contextual. A password and a one-time-code application running on the same compromised device may both be exposed by one attack. Push approval can be undermined by repeated prompts that induce an accidental or fatigued acceptance. Strong multifactor systems therefore depend not merely on counting factors but on how factors are protected, how approval is tied to the intended service, and whether the claimant can distinguish a legitimate request from an attacker-generated one."
    },
    {
      "heading": "Cryptographic protocols and authentication guarantees",
      "text": "Cryptographic authentication establishes evidence through operations on keys and messages. In a challenge–response protocol, a verifier sends an unpredictable challenge, and the claimant returns a value computed using a secret or private key. The verifier checks the response. Fresh challenges prevent an attacker from satisfying a new exchange merely by replaying a previously recorded response. The challenge must be generated and checked correctly; a repeated or predictable value can undermine this protection.\n\nWith shared-key authentication, both parties know the same secret. A message authentication code authenticates a message relative to that shared key. This can provide efficient data-origin authentication and integrity, but either key holder can generate a valid code. It therefore does not provide evidence that uniquely distinguishes one shared-key holder from another. With public-key cryptography, a claimant can instead demonstrate possession of a private key whose corresponding public key is already trusted.\n\nA digital signature verifies a relationship between a message and a private key, not automatically between a message and a legally identified person. That additional meaning depends on how the public key is associated with an identity and on the security of the signing process. Public-key infrastructure commonly uses certificates signed by certification authorities to record such bindings. Certificate validation may involve a chain of signatures, acceptable names, validity periods, usage constraints, and revocation information.\n\nProtocol context matters as much as the cryptographic primitive. A valid signature over an isolated challenge can be insufficient if the same signature is usable for another purpose or another peer. Secure protocols bind evidence to relevant context, potentially including the identities of the participants, the negotiated algorithms, the intended service, and previous messages. Otherwise, attacks may exploit reflection, role confusion, or disagreements about which peer shares a key. Formal security properties often distinguish merely establishing participation from agreement on particular session data.\n\nTransport Layer Security illustrates how several mechanisms work together. In TLS 1.3, standardized in RFC 8446 in 2018, certificate-based authentication includes signatures tied to the handshake transcript, while Finished messages authenticate the handshake using derived secrets. The protocol can authenticate a server and optionally a client. Ordinary website deployments usually authenticate the server at this layer and the user at an application layer.\n\nAuthentication and confidentiality are separate properties. Encryption conceals data, but encryption without suitable integrity protection does not necessarily establish who produced it or whether it was modified. Conversely, an authenticated signed message may be publicly readable. A protocol’s guarantees must therefore be stated explicitly: peer identity, message integrity, freshness, key agreement, and confidentiality are related goals, not interchangeable labels for security."
    },
    {
      "heading": "Web authentication and session management",
      "text": "A web login usually establishes a session rather than requiring the user to authenticate separately for every request. After successful authentication, a server often issues an unpredictable session identifier in an HTTP cookie. Subsequent requests carrying that identifier are associated with server-side session state. Alternatively, a service may issue a self-contained token whose integrity it can verify. In either design, possession of the session credential can be sufficient to act as the user.\n\nThis creates a boundary between authentication security and session security. An attacker who steals a valid session token may bypass the login mechanism entirely, including multifactor authentication. The original authentication may have been strong while the resulting session remains vulnerable. Session identifiers therefore require adequate unpredictability and protection during transmission, storage, and use. Cookies marked Secure are restricted to secure connections; HttpOnly restricts access through browser scripting interfaces; SameSite influences when cookies accompany cross-site requests. These controls address different threats and do not substitute for one another.\n\nSession fixation occurs when an attacker causes a victim to authenticate using a session identifier the attacker already knows. Issuing a fresh identifier when authentication or privilege level changes helps separate the new authenticated state from earlier untrusted state. Session expiration likewise has multiple meanings. An idle timeout ends a session after inactivity, while an absolute timeout limits its total duration. Reauthentication for a sensitive action can provide fresher evidence than the existence of a long-lived session alone.\n\nBrowsers add an origin-based security model. Scripts, cookies, frames, and navigations are governed by rules involving schemes, hosts, and other attributes. Cross-site request forgery exploits situations in which a browser automatically attaches an authenticated credential to an attacker-induced request. The request may reach the legitimate service with the user’s session cookie even though the user did not intend the action. Cross-site scripting presents a different problem: code executing in the application’s origin can interfere with authenticated operations, sometimes without needing to read the session cookie.\n\nWeb Authentication, commonly called WebAuthn, is a browser-facing standard developed by the World Wide Web Consortium. Its first Level 1 Recommendation was published in 2019. It allows web applications to create and use public-key credentials through authenticators. Authentication assertions incorporate a challenge and information tied to the requesting origin and relying party. The service verifies these bindings alongside the signature, reducing the usefulness of a credential captured by an unrelated phishing site.\n\nLogout is consequently more than changing a page’s appearance. It may require invalidating server-side state, clearing local credentials, revoking refresh capability, and handling sessions on other devices. A system using independently verifiable tokens may retain valid tokens until expiration unless it implements additional revocation mechanisms. The exact effect of logout is therefore an architectural property, not a universal consequence of a logout button."
    },
    {
      "heading": "Federation, single sign-on, and delegated access",
      "text": "Federated identity allows one organization or service to rely on identity information supplied by another. The participant authenticating the user is commonly called an identity provider, while the application accepting its assertion is a relying party or service provider. Federation can support single sign-on, in which one authentication event enables access to several applications. Single sign-on can also exist within a single administrative domain, so the two terms are related but not identical.\n\nFederation changes where trust is placed. A relying party must validate not only an assertion’s cryptographic integrity but also its issuer, intended audience, validity interval, and relationship to a specific authentication request. An assertion that is valid for one application is not automatically valid for another. Replay protection, correct endpoint configuration, and unambiguous account identifiers are important because the relying party is accepting a statement produced elsewhere rather than directly checking the user’s original authenticator.\n\nSecurity Assertion Markup Language, or SAML, uses XML-based assertions to communicate authentication and attribute information. SAML 2.0 became an OASIS standard in 2005 and is widely associated with enterprise browser single sign-on. A typical flow redirects a browser to an identity provider and returns an authentication response to the service provider. Correct validation must account for both the protocol and the signed document structure; verifying a signature somewhere in a document is insufficient if the application then trusts different, unsigned content.\n\nOAuth addresses delegated authorization rather than authentication by itself. OAuth 2.0, standardized in RFC 6749 in 2012, allows a client to obtain limited access to a protected resource using access tokens. A user authorizing a calendar application to read appointments is granting access, not necessarily providing that application with a standardized statement of personal identity. Treating an arbitrary access token as a login credential can therefore produce incorrect assumptions about its recipient, purpose, or user binding.\n\nOpenID Connect, finalized in 2014, adds an identity layer to OAuth 2.0. Its ID Token communicates claims about an authentication event and an identified subject. An ID Token and an access token have different audiences and purposes. Validation includes checking the issuer, intended client, expiry, and applicable request-binding values. Proof Key for Code Exchange, or PKCE, binds authorization-code redemption to a secret generated for the initiating exchange, mitigating certain code-interception attacks.\n\nFederation reduces the need for every application to handle primary credentials, but it also concentrates risk and creates dependencies. An identity-provider outage can block access to many services, and compromise can affect multiple relying parties. Privacy concerns arise when a provider can observe sign-ins across services or when stable identifiers enable correlation. Pairwise identifiers can reduce direct cross-service correlation, although they do not eliminate information disclosed through attributes, network observations, or application behavior."
    },
    {
      "heading": "Device and service authentication in distributed systems",
      "text": "Authentication also applies to entities that have no human operator at the moment of use. Servers, containers, background jobs, routers, and connected devices must establish which other components they are communicating with. In distributed computing, this often requires managing identities at a much larger scale and shorter lifetime than traditional employee accounts. A single application may involve hundreds of interacting services, each requiring credentials and narrowly defined permissions.\n\nMachine credentials include shared secrets, application keys, certificates, and tokens issued to a workload. An application programming interface key is often a bearer credential: whoever possesses it can use it, subject to server-side restrictions. It may identify a project or client rather than an individual user. Embedding such a secret in publicly distributed software does not reliably keep it confidential, because users or attackers can inspect the program and its execution environment.\n\nMutual TLS authenticates both endpoints through the transport protocol, commonly using certificates. It can distinguish authorized services without transmitting reusable passwords on each request. Nevertheless, successful certificate authentication does not determine every application permission. A service may be permitted to connect while still lacking authorization to invoke a particular operation or access a particular tenant’s data. Certificate issuance, private-key protection, rotation, and trust-store configuration become major operational concerns.\n\nKerberos, developed at MIT as part of Project Athena, provides an influential ticket-based approach to network authentication. Its Version 5 specification was published in RFC 1510 in 1993 and updated in RFC 4120 in 2005. A trusted key distribution center issues credentials enabling clients to obtain service tickets. A service ticket carries information protected for the target service, while authenticators help demonstrate current possession of the relevant session key. Kerberos reduces repeated exposure of long-term secrets but relies on the trusted infrastructure and appropriately synchronized clocks.\n\nModern cloud computing platforms often issue short-lived credentials to workloads based on their execution environment. This avoids distributing a single permanent secret to every process, but moves trust into the platform’s mechanisms for identifying instances, containers, or service accounts. Credential-delivery interfaces themselves become sensitive attack surfaces. An application vulnerability that permits access to a local credential endpoint can expose privileges even when the application has no hard-coded secret.\n\nDevice authentication may also use hardware-backed keys and attestation. Attestation supplies evidence about properties of a device, authenticator, or execution environment; it is not equivalent to authenticating a person or proving an application’s overall correctness. Within zero-trust architecture, network location alone is not sufficient evidence of trust. Requests can instead be evaluated using authenticated identities and contextual signals, while least privilege limits the consequences when one authenticated component is compromised."
    },
    {
      "heading": "Attacks, assurance, and evaluation",
      "text": "Authentication failures can occur at every layer of a system. Phishing persuades users to disclose credentials or approve attacker-initiated requests. Social engineering can target support staff rather than the login interface. Replay reuses captured evidence, while adversary-in-the-middle attacks relay interactions between a victim and a genuine service. Malware can steal credentials before protection is applied or act through an already authenticated endpoint. These mechanisms require different defenses because they exploit different trust assumptions.\n\nPhishing resistance has a more specific meaning than general resistance to account takeover. An authenticator bound cryptographically to the intended verifier can prevent a fraudulent site from obtaining an authentication response usable at the legitimate site. Manually entered one-time codes generally lack that binding and can be relayed. Even a phishing-resistant login does not prevent every subsequent abuse: malicious browser extensions, session theft, compromised applications, and deceptive requests within a legitimate service can remain relevant.\n\nAssurance frameworks distinguish the strength of identity proofing, authentication, and federation. The United States National Institute of Standards and Technology’s Special Publication 800-63 family separates these concerns rather than treating them as a single security score. The 800-63-3 suite, published in 2017, formalized distinct identity, authenticator, and federation assurance levels. Such frameworks connect technical requirements to an assessed risk, but a declared assurance level depends on the complete implemented process, including lifecycle and recovery controls.\n\nEvaluation requires several kinds of evidence. Cryptographic analysis examines whether the protocol satisfies defined properties under stated assumptions. Formal verification can identify flaws in protocol logic, such as replay opportunities or disagreement about peer identities. Implementation testing examines parsing, state transitions, error handling, and key management. Operational assessment considers enrollment fraud, administrative privileges, recovery procedures, and how users actually interact with prompts. A mathematically sound protocol can still fail through an implementation defect or an insecure deployment.\n\nUsability and accessibility affect security outcomes. An authentication mechanism that some users cannot operate may lead to weaker fallback procedures or dependence on intermediaries. Biometrics can fail under particular physical or environmental conditions; hardware tokens can be lost; mobile-device requirements can exclude users without compatible devices. Accessibility is therefore relevant to the effective assurance of the whole system, not merely to the presentation of its login page.\n\nAuthentication also creates privacy and measurement challenges. Risk-based systems may use location, device characteristics, and behavioral signals to assess a login, but these signals are probabilistic and can generate false alarms or reveal personal patterns. Failure rates, account-takeover rates, recovery completion, and attack-detection rates measure different outcomes. Comparisons are meaningful only when deployment populations, attacker capabilities, observation periods, and definitions are sufficiently clear."
    }
  ],
  "links": [
    "cybersecurity",
    "cryptography",
    "access-control",
    "malware",
    "social-media",
    "time-sharing",
    "cryptographic-hash-function",
    "denial-of-service-attack",
    "transport-layer-security",
    "multifactor-authentication",
    "message-authentication-code",
    "public-key-cryptography",
    "digital-signature",
    "encryption",
    "http-cookie",
    "world-wide-web-consortium",
    "distributed-computing",
    "application-programming-interface",
    "kerberos",
    "cloud-computing",
    "zero-trust-architecture",
    "least-privilege",
    "phishing",
    "social-engineering",
    "formal-verification",
    "web-accessibility"
  ],
  "sources": [],
  "license": "https://creativecommons.org/licenses/by/4.0/"
}