{
  "id": "https",
  "title": "HTTPS",
  "lang": "en",
  "source_lang": "en",
  "summary": "HTTPS secures HTTP communication using TLS, providing encryption, integrity protection, and authentication for websites and other network services.",
  "category": "computer-science",
  "subcategory": "networks-security",
  "type": "concept",
  "aliases": [
    "Hypertext Transfer Protocol Secure",
    "HTTP Secure",
    "HTTP over TLS"
  ],
  "generated_at": "2026-11-02",
  "model": "pro/gpt-6.1-sol",
  "url": "https://aiwiki.page/en/https/",
  "translations": {
    "zh-Hans": {
      "url": "https://aiwiki.page/zh/https/",
      "json": "https://aiwiki.page/zh/https.json"
    }
  },
  "sections": [
    {
      "heading": "",
      "text": "HTTPS is the secure form of the Hypertext Transfer Protocol (HTTP), the application protocol underlying much of the World Wide Web. It protects communication using Transport Layer Security (TLS), combining confidentiality, integrity protection, and authentication of the communicating service. An HTTPS address begins with https://; its default port is 443. Although commonly described as “encrypted HTTP,” HTTPS also establishes whether the remote endpoint is authorized to represent the requested hostname.\n\nHTTPS is a central component of cybersecurity on the Internet. It protects activities ranging from reading public pages to exchanging passwords, making purchases, and calling an application programming interface (API). Its protection is specific: it secures data between TLS endpoints, not every system through which that data may subsequently pass. Understanding HTTPS therefore involves its protocol architecture, certificate-based trust, browser security rules, operational deployment, and the limits of transport encryption."
    },
    {
      "heading": "Origins and standardization",
      "text": "HTTPS originated in the early commercial Web, when browsers needed to transmit payment details and other sensitive information over networks that offered no built-in confidentiality. Netscape introduced support for secure HTTP connections in its browser products in 1994. The underlying technology was Secure Sockets Layer (SSL), a protocol developed to protect application traffic without requiring a complete redesign of HTTP. SSL 2.0 became publicly available in 1995, followed by SSL 3.0 in 1996. Both are now obsolete and unsuitable for secure deployment.\n\nTLS succeeded SSL through work at the Internet Engineering Task Force (IETF). TLS 1.0 was published as RFC 2246 in January 1999, retaining much of the architecture of SSL 3.0 while changing cryptographic details. RFC 2818, published in May 2000, described HTTP over TLS, including the https scheme, server identity checking, and connection behavior. Later HTTP specifications incorporated and refined HTTPS semantics; RFC 9110, published in 2022, defines the modern meaning of the scheme. The name “HTTPS” consequently denotes a standardized way of securing HTTP rather than an unrelated replacement application protocol.\n\nThe cryptographic foundation evolved substantially. TLS 1.1 appeared in 2006, TLS 1.2 in 2008, and TLS 1.3 in 2018. TLS 1.3, specified in RFC 8446, removed numerous older options, simplified negotiation, and reduced the latency of establishing secure connections. SSL 3.0 was formally deprecated in 2015, while TLS 1.0 and TLS 1.1 were deprecated by the IETF in 2021. These dates distinguish historical compatibility from contemporary security: software may still recognize an old protocol without that protocol being acceptable for new connections.\n\nHTTPS adoption also changed in scope. Early sites often encrypted only login and payment pages, leaving ordinary browsing on plaintext HTTP. That arrangement exposed session identifiers, enabled modification of unencrypted pages, and allowed attackers to interfere before a user reached a protected page. During the 2010s, automated certificate issuance, browser policy changes, and growing attention to pervasive monitoring encouraged encryption of entire sites. Let’s Encrypt began public operation in 2015 and made automated, publicly trusted certificates widely accessible. HTTPS increasingly became a default transport for the Web rather than a special mode reserved for visibly sensitive transactions."
    },
    {
      "heading": "Protocol architecture and addressing",
      "text": "HTTPS preserves HTTP’s application-level model. Clients still send requests containing methods such as GET or POST, target resources, headers, and sometimes message bodies; servers return status codes, headers, and content. TLS protects the exchange rather than redefining what those messages mean. An encrypted response can therefore carry an ordinary HTML document, a video segment, a structured API response, or an error page. Application errors and transport security are separate properties: a correctly authenticated HTTPS connection may legitimately return an HTTP 404 or 500 response.\n\nFor HTTP/1.1 and HTTP/2, the usual stack places HTTP above TLS, with TLS above the Transmission Control Protocol (TCP). TCP supplies a reliable, ordered byte stream, and TLS turns that stream into an authenticated, encrypted channel. HTTP/2 multiplexes multiple exchanges over one connection, but packet loss can still delay all streams because TCP must restore byte order. This is transport-level head-of-line blocking, distinct from the scheduling of individual HTTP requests.\n\nHTTP/3 uses QUIC instead. QUIC runs over UDP and integrates the TLS 1.3 handshake with its own packet protection and stream transport. It does not simply place ordinary TLS records inside a TCP connection. Independent QUIC streams reduce the cross-stream blocking caused by lost transport packets, although shared congestion control and application dependencies still affect performance. The https scheme is used for HTTP/3 as well as earlier HTTP versions; it identifies the secure service, not one fixed transport stack.\n\nAn HTTPS address also has consequences for identity and origin. In https://shop.example:443/account, the scheme is https, the hostname is shop.example, the explicit port is 443, and the path is /account. Omitting the port selects the scheme’s default. The hostname normally identifies the server name that certificate validation must authenticate. The path and query are transmitted within the protected HTTP exchange; a fragment identifier, if present, is normally interpreted by the client and is not sent as part of the request target.\n\nFor browser security, scheme, host, and port jointly define an origin. Thus http://example.com and https://example.com are different origins even when operated by the same organization. The same-origin policy uses this distinction to limit interactions between documents and resources. Port 443 is a convention, not a prerequisite for encryption: an HTTPS service can operate on another port, and merely placing an unencrypted service on port 443 does not make it HTTPS."
    },
    {
      "heading": "TLS negotiation and cryptographic protection",
      "text": "A secure connection begins with negotiation rather than immediate transmission of ordinary application data. In a typical TLS 1.3 handshake, the client sends a ClientHello containing supported protocol versions, cryptographic options, and key-share information. The server selects compatible parameters and returns a ServerHello with its own key share. Both sides derive shared secrets, while subsequent handshake messages establish the server’s identity and confirm that the negotiation has not been altered. Most handshake content after ServerHello is encrypted.\n\nModern TLS separates key establishment from bulk data protection. An ephemeral Diffie–Hellman key exchange, commonly using elliptic curves, allows the endpoints to derive a shared secret without transmitting it directly. The server then uses a digital signature to demonstrate possession of the private key corresponding to its certificate and to bind its identity to the handshake. The certificate’s public key does not ordinarily encrypt every HTTP message. Instead, derived symmetric traffic keys protect the much larger volume of application data.\n\nTLS 1.3 uses authenticated encryption with associated data, or AEAD, for its protected records. Examples include AES-GCM and ChaCha20-Poly1305. These constructions combine confidentiality with a cryptographic integrity check. Conceptually, record protection can be represented as\n\n\\[(C,T)=\\operatorname{AEAD\\_Encrypt}(K,N,P,A),\\]\n\nwhere \\(K\\) is a traffic key, \\(N\\) is a nonce, \\(P\\) is plaintext, \\(A\\) is authenticated additional data, \\(C\\) is ciphertext, and \\(T\\) is an authentication tag. A receiver rejects a record whose authentication check fails. This prevents an intermediary from making controlled, undetected edits to protected HTTP messages.\n\nEphemeral key agreement provides forward secrecy: later theft of the server’s long-term authentication key does not by itself reveal previously recorded sessions whose ephemeral secrets have been erased. This differs from older TLS arrangements using RSA key transport, in which compromise of the relevant private key could expose recorded sessions. Forward secrecy depends on the actual key establishment mode and secret handling, not merely on the presence of a certificate or an HTTPS address.\n\nTLS can also resume previous sessions. In TLS 1.3, resumption uses a pre-shared key derived from an earlier connection, often represented to the client through a server-issued ticket. This can reduce authentication work and enable early application data. However, optional zero-round-trip, or 0-RTT, data has weaker replay guarantees than ordinary post-handshake traffic. A captured early request may be replayed under some conditions, so servers and application protocols must distinguish replay-tolerant operations from actions such as executing a purchase."
    },
    {
      "heading": "Certificates and the public trust system",
      "text": "Most public HTTPS authentication depends on a public key infrastructure built around X.509 certificates. A certificate associates a public key with identifiers, usually DNS hostnames, and includes validity dates, issuer information, permitted uses, and a digital signature. The client evaluates whether this statement can be connected through a valid chain to a trust anchor it already accepts. Browsers and operating systems distribute collections of trusted root certificates, although their policies and root stores are not necessarily identical.\n\nA typical chain contains a server certificate, one or more intermediate certificates, and a root trust anchor. The server normally supplies its certificate and the necessary intermediates; the root is usually already available to the client. Validation checks include signatures, validity periods, certificate constraints, and suitability for server authentication. The client also verifies that the requested hostname matches an identifier in the certificate’s Subject Alternative Name extension. A certificate for example.com does not automatically authenticate example.net or every subdomain of example.com.\n\nWildcard certificates have limited matching rules. A DNS identifier such as *.example.com ordinarily covers shop.example.com, but not the bare name example.com or a deeper name such as a.shop.example.com. Certificates can also list several distinct names. These rules are important for shared hosting and service consolidation: a secure connection must authenticate the name the client intended to reach, not merely prove that the server owns some valid certificate.\n\nA certificate authority (CA) issues certificates after carrying out the validation appropriate to its certificate type and policies. Domain-validated certificates establish authorization over the named domain; they do not certify the truthfulness of its content or the reliability of its operator. Organization-validated and extended-validation certificates include additional identity checks, but they use the same underlying transport mechanisms. A phishing site can obtain a valid certificate for a domain it controls, which is why certificate validity and business legitimacy must not be treated as synonyms.\n\nCertificate status and oversight extend beyond issuance. Revocation mechanisms include certificate revocation lists and the Online Certificate Status Protocol, or OCSP, although client enforcement and failure behavior vary. OCSP stapling allows the server to supply a signed status response instead of requiring each client to contact the issuer separately. Certificate Transparency adds publicly auditable, append-only certificate logs that help reveal misissuance. Logging does not itself prove that issuance was authorized, and revocation does not guarantee that every client immediately stops accepting a certificate. Public HTTPS trust is therefore a combination of cryptography, software policy, operational controls, and institutional accountability."
    },
    {
      "heading": "Security guarantees and their boundaries",
      "text": "HTTPS protects against important classes of network adversary. A passive observer between the TLS endpoints cannot normally read protected request headers, response bodies, passwords, or cookies. An active intermediary cannot silently rewrite those messages without defeating authentication or record protection. When certificate validation succeeds, the client has cryptographic evidence that the peer is authorized to represent the requested service name under the client’s trust policy. These properties are particularly significant on shared wireless networks and other paths containing intermediaries outside the user’s control.\n\nThe protection is not complete traffic anonymity. An observer can generally see network addresses, connection timing, and approximate traffic volume. Conventional DNS resolution may reveal the requested hostname, and the TLS Server Name Indication extension has traditionally exposed a hostname in the initial handshake. Encrypted Client Hello (ECH) protects sensitive portions of that handshake where supported and correctly deployed. Even then, a destination address, traffic pattern, or other side channel may help an observer infer the service. HTTPS privacy therefore depends partly on surrounding protocols, including the Domain Name System.\n\nHTTPS is also limited by its endpoints. The server can read the HTTP messages it decrypts; so can any authorized TLS terminator placed in front of it. If a content delivery service terminates the connection, protection between the browser and that service is distinct from protection between the service and the application’s origin server. HTTPS is consequently not equivalent to application-level end-to-end encryption, in which an intermediary service lacks access to plaintext content.\n\nCompromised endpoints can defeat the intended protection without breaking TLS. Malware on a client may read information before encryption or after decryption. A compromised server may expose received data, and an application may record secrets in logs or send them to another service. HTTPS does not determine how long a database retains a message, who has administrative access, or whether application authorization rules are correct. Its threat model concerns the transport channel rather than every stage of data handling.\n\nNor does HTTPS establish that a website is harmless. A validly authenticated site may distribute malware, publish false claims, or conduct phishing. Network encryption does not prevent a user from entering credentials into the wrong domain. It also does not guarantee availability: an attacker can block connections, disrupt routing, or overload a service. These distinctions explain why browser connection indicators describe a channel property rather than endorsing the operator, content, or purpose of a website."
    },
    {
      "heading": "Browser enforcement and web application security",
      "text": "Browsers combine HTTPS with rules governing how documents load resources and use sensitive capabilities. A page fetched securely can lose much of its protection if it executes a script obtained through an unauthenticated channel. An attacker able to replace that script could alter the page or access data available to it. Browsers therefore restrict mixed content: resources requested through insecure transport from a secure document. Scripts and other active content face particularly strict treatment; some other resource types may be upgraded to HTTPS or blocked according to browser policy.\n\nHTTP Strict Transport Security (HSTS), standardized in RFC 6797 in 2012, lets a host instruct browsers to use HTTPS for future connections during a stated period. The instruction is delivered through the Strict-Transport-Security response header over an authenticated secure connection. Once the policy is stored, the browser upgrades matching HTTP navigations before sending an insecure request and treats certificate errors more strictly. An optional includeSubDomains directive extends the policy to subdomains.\n\nHSTS addresses a weakness that a simple HTTP redirect cannot fully solve. If a user first visits an HTTP address, an on-path attacker may interfere before the redirect to HTTPS is received. A remembered HSTS policy prevents that initial plaintext step on subsequent visits. Browser-distributed preload lists can protect a host even before a particular user’s first visit, subject to the browser’s list and inclusion rules. Preloading and broad subdomain coverage also create deployment obligations: every covered service must remain reachable through valid HTTPS.\n\nCookies require additional controls. A cookie marked Secure is restricted to secure transport under browser rules, reducing the chance that it will be exposed through an HTTP request. HttpOnly prevents ordinary script access to the cookie, while SameSite constrains its inclusion in certain cross-site requests. These attributes address different risks. HTTPS alone does not prevent a malicious script running within the application’s origin from performing actions with the user’s authority, nor does it replace defenses against cross-site request forgery.\n\nMany browser capabilities are restricted to secure contexts, generally authenticated HTTPS contexts together with specified trustworthy exceptions such as certain local development origins. Examples include service workers, geolocation, and several device-access interfaces. A secure context is a platform classification, not merely a visual property of the address bar, and embedding relationships can affect eligibility. Other controls, including Content Security Policy and application authorization, operate alongside HTTPS. Transport protection establishes a necessary foundation for many browser features without making insecure application behavior safe."
    },
    {
      "heading": "Deployment, termination, and certificate automation",
      "text": "A deployed HTTPS service needs a compatible TLS implementation, a certificate and corresponding private key, and configuration that connects the authenticated name to the intended application. In a simple arrangement, a web server handles both TLS and HTTP. Larger systems commonly place TLS termination in a reverse proxy, load balancer, or content delivery network (CDN). That component decrypts incoming traffic and forwards requests to application servers, potentially using a separate HTTPS connection.\n\nThis architecture changes the trust boundary. If the frontend forwards plaintext over an internal network, the external user’s HTTPS connection does not protect that internal segment. If it uses a second TLS connection, the frontend becomes both a TLS server to the user and a TLS client to the backend. Backend authentication must then be configured for that relationship. The result is two protected channels with a trusted intermediary, not one uninterrupted cryptographic channel from browser to application process.\n\nShared hosting relies heavily on Server Name Indication (SNI), a TLS extension through which the client indicates the hostname it wants. The server can then select the appropriate certificate before receiving the encrypted HTTP request. This permits many HTTPS hostnames to share one network address. Application-Layer Protocol Negotiation, or ALPN, serves a different purpose: it selects an application protocol, such as HTTP/2 or HTTP/1.1, during connection establishment. SNI identifies the requested virtual service; ALPN identifies how application messages will be exchanged.\n\nCertificate automation is commonly implemented through the Automated Certificate Management Environment (ACME), standardized in RFC 8555 in 2019. ACME coordinates account registration, identifier validation, issuance, and renewal. Depending on the challenge type, a client may demonstrate domain control by provisioning an HTTP resource or a DNS record. Automation reduces manual certificate handling but introduces dependencies on challenge routing, DNS credentials, renewal scheduling, and reliable deployment of the resulting certificate chain.\n\nPrivate keys require protection independently of certificate issuance. They may be stored in restricted files, managed key services, or a hardware security module that performs private-key operations without exposing the key directly to application software. Operational failures include expired certificates, missing intermediates, hostname mismatches, and inconsistent certificates across geographically distributed servers. In organizational environments, mutual TLS can additionally authenticate clients using certificates. This is common in service-to-service communication, but it establishes possession of a client credential rather than automatically defining the application permissions associated with that client."
    },
    {
      "heading": "Performance and connection management",
      "text": "HTTPS adds cryptographic computation and connection-establishment work, but its performance cannot be described by one fixed overhead percentage. Costs vary with protocol version, network latency, processor capabilities, certificate chain size, connection reuse, and workload. Public-key operations are concentrated in connection establishment, while symmetric encryption protects most application bytes. Modern processors often accelerate common cryptographic algorithms, making network delay and application processing more significant than bulk encryption for many workloads.\n\nRound trips are especially important on long-distance and mobile connections. In a common new TCP-based deployment, TCP establishment occurs before the TLS handshake. TLS 1.3 normally requires one additional network round trip after the client begins the handshake before ordinary authenticated application traffic can proceed; TLS 1.2 commonly requires more handshake exchange. These are protocol-level descriptions rather than universal page-load measurements. DNS resolution, packet loss, certificate processing, congestion control, and browser scheduling also contribute to the observed delay.\n\nConnection reuse amortizes establishment costs. HTTP/1.1 persistent connections allow several requests over an existing connection, while HTTP/2 multiplexes concurrent streams. Browsers can sometimes coalesce requests for multiple origins onto one connection when certificate coverage and other authority checks permit it. This reduces repeated handshakes, but it does not eliminate origin-based security rules. One authenticated transport connection may carry requests for more than one authorized origin without making those origins interchangeable to scripts.\n\nQUIC combines transport establishment with TLS negotiation, allowing HTTP/3 to avoid the strictly separate TCP-then-TLS sequence. It also supports connection continuity across some network changes, such as movement between Wi-Fi and cellular service, using connection identifiers rather than relying solely on an unchanged network-address tuple. These features can improve responsiveness, but results depend on network conditions and implementation. UDP blocking, congestion behavior, and server resource limits can affect whether HTTP/3 is usable or beneficial.\n\nResumption and 0-RTT trade additional complexity for lower latency. Early data can let a returning client send a request before completing a fresh handshake, but replay risks constrain suitable operations. HTTP status code 425 Too Early, defined in RFC 8470 in 2018, provides a mechanism for refusing requests that a server is unwilling to process under those conditions. Session tickets also require careful key management and privacy considerations. Performance mechanisms therefore interact with authentication state, replay handling, and connection linkability rather than being purely mechanical accelerators."
    },
    {
      "heading": "Attacks, implementation failures, and protocol evolution",
      "text": "Attacks on HTTPS occur at several layers: cryptographic design, protocol negotiation, software implementation, certificate issuance, and application behavior. Historical weaknesses illustrate these distinctions. BEAST, disclosed in 2011, exploited properties of older TLS CBC-mode encryption under particular conditions. POODLE, disclosed in 2014, targeted SSL 3.0 CBC padding and was especially significant when connections could be forced to fall back to that obsolete protocol. Their remedies involved protocol and configuration changes, not replacing HTTP methods or page formats.\n\nHeartbleed, disclosed in 2014, was different. It was a memory-disclosure vulnerability in OpenSSL’s implementation of the TLS heartbeat extension. A vulnerable process could return memory beyond the intended message contents, potentially exposing sensitive material. The flaw did not demonstrate that the TLS protocol’s cryptographic primitives had been mathematically broken. It showed that a secure protocol design can still be undermined by unsafe parsing and memory handling in a widely deployed implementation.\n\nCompression has also produced side channels. CRIME, disclosed in 2012, exploited compression before encryption, while BREACH, disclosed in 2013, applied a related principle to compressed HTTP responses. If attacker-controlled input and a secret influence the same compressed output, changes in encrypted message length may reveal information about the secret over repeated observations. TLS can conceal the bytes while still exposing enough length information for an attack. Removing TLS-level compression does not automatically eliminate analogous application-level compression risks.\n\nAuthentication failures form another class. A misissued certificate, stolen private key, overly broad enterprise trust anchor, or client that fails to check hostnames can allow an unauthorized party to impersonate a service. Interception products sometimes install a local trusted root and generate substitute certificates so that they can inspect traffic. From the browser’s perspective, this changes who is trusted to terminate HTTPS. The encrypted connections may remain cryptographically valid while the original expectation of a direct browser-to-service channel no longer holds.\n\nProtocol development continues to address both visible weaknesses and structural limits. TLS 1.3 removed legacy constructions and incorporated downgrade defenses; ECH aims to reduce exposed handshake metadata. Research on post-quantum cryptography addresses the possibility that sufficiently capable quantum computers could defeat widely used public-key algorithms. This is particularly relevant to encrypted traffic recorded for later decryption, although new key-establishment mechanisms must also satisfy performance, interoperability, and implementation requirements. Formal verification, implementation testing, and careful analysis of protocol composition remain important because HTTPS security depends on the interaction of cryptography, state machines, trust decisions, and application use."
    }
  ],
  "links": [
    "hypertext-transfer-protocol",
    "world-wide-web",
    "transport-layer-security",
    "cybersecurity",
    "internet",
    "application-programming-interface",
    "internet-engineering-task-force",
    "digital-signature",
    "operating-system",
    "domain-name-system",
    "database",
    "phishing",
    "http-cookie",
    "post-quantum-cryptography",
    "formal-verification"
  ],
  "sources": [],
  "license": "https://creativecommons.org/licenses/by/4.0/"
}