HTTPS combines HTTP with SSL/TLS to protect data through encryption, integrity checks, and authentication, using asymmetric keys during the handshake to negotiate symmetric encryption, digital signatures, certificates, and a secure session, ensuring safe client‑server communication.
This article explains the fundamentals of the HTTP protocol, illustrates its vulnerability to man‑in‑the‑middle attacks, and details how HTTPS—through SSL/TLS, asymmetric key exchange, and a trusted CA certificate hierarchy—secures communications by encrypting data and preventing interception and tampering.
This article explains the fundamentals of HTTP, the differences between GET and POST, common status codes, HTTPS and TLS handshakes, the improvements introduced by HTTP/2 such as binary framing, multiplexing and header compression, as well as the role of QUIC and DNS in the end‑to‑end web request flow.
This guide walks through the new features of Elastic Stack 7.9 and shows step‑by‑step how to provision a three‑node Elasticsearch cluster on a local Mac using Vagrant, enabling security, TLS, API keys, and providing all necessary scripts, configuration files, and verification commands.
Kubernetes 1.19, released after a 20‑week cycle, introduces a one‑year support window, storage capacity tracking, generic ephemeral volumes, CSI health monitoring, Ingress reaching GA, structured logging, new klog methods, and kubelet TLS certificate rotation, while providing extensive release notes and ecosystem updates.
This article provides a comprehensive overview of HTTP fundamentals, compares GET and POST, explains common status codes, details HTTPS and TLS mechanisms, introduces HTTP/2 features such as binary framing, header compression and server push, and walks through the full request‑response flow from DNS lookup to page rendering.
Learn how to protect Docker’s exposed remote management port 2375 by generating CA, server, and client certificates with OpenSSL, configuring Docker daemon for TLS verification, and adjusting docker-maven-plugin settings to safely build and push images without exposing insecure endpoints.
As IoT devices proliferate across industries, their fragmented, resource‑constrained nature and continuous operation create security challenges distinct from traditional Internet security, prompting the need for specialized authentication, lightweight TLS, secure chips, trusted execution environments, software hardening, and emerging standards to protect the ecosystem.
This article explains why HTTP is insecure, demonstrates a plain‑text attack using Wireshark, and then details the encryption types, certificate issuance, digital signatures, and the combined asymmetric‑symmetric handshake that make HTTPS a secure protocol for web communication.
This article explains in plain language what HTTPS is, how it encrypts data using symmetric and asymmetric techniques, how it verifies server identity with digital signatures and certificates, and why these mechanisms keep web communications safe from eavesdropping and tampering.
The article critiques the modern Web’s complexity, introduces the Gemini protocol as a lightweight, TLS‑only alternative inspired by Gopher and markdown, outlines its features and limitations—such as lack of styling, images, and large‑file support—and suggests use cases like text‑centric blogs and personal sites.
Learn how to build a three‑node Elasticsearch cluster with full TLS encryption, configure Kibana’s HTTPS settings, create minimal‑privilege Beats‑writer roles, and eliminate clear‑text passwords using Elastic Stack’s keystore, all within a reproducible Vagrant environment for secure, scalable monitoring.
This article explains why HTTPS is essential, compares symmetric and asymmetric encryption, illustrates how encryption keys are securely exchanged, and outlines the three core reasons HTTPS reliably protects data from eavesdropping and man‑in‑the‑middle attacks.
This article explains how HTTPS security depends on certificates, outlines the risks of certificate forgery, describes the certificate issuance process, and introduces Certificate Transparency and the Expect-CT header as mechanisms to detect and mitigate forged certificates.
This guide explains why Zabbix data transmission in mixed‑cloud environments requires encryption, describes the TLS/PSK and certificate‑based security options supported since Zabbix 3.0, outlines their limitations, lists compatible encryption libraries, and provides step‑by‑step configuration commands for both GnuTLS and OpenSSL.
This article explains why HTTPS is essential for protecting privacy, ensuring data integrity, and authenticating servers, describes the evolution of SSL/TLS, and walks through the handshake process that combines asymmetric and symmetric encryption to secure web traffic.
This article explains why HTTPS is considered secure, details its underlying cryptographic processes—including certificate verification, asymmetric and symmetric encryption, and the role of Certificate Authorities—while also addressing common misconceptions such as man‑in‑the‑middle attacks and packet capture.
This article explains why HTTPS is necessary, describes symmetric and asymmetric encryption, illustrates the key exchange process, and outlines how HTTPS ensures secure communication by preventing eavesdropping, man‑in‑the‑middle attacks, and ensuring certificate trustworthiness.
This guide explains Kubernetes service exposure options, the challenges they address, and provides a step‑by‑step tutorial for deploying an Ingress controller, creating Ingress resources, and configuring TLS to securely expose applications within a cluster.
This article details a two‑day troubleshooting process that identified missing SSL certificates and TLS configuration as the cause of Jenkins Artifactory plugin upload failures on AIX, and explains how setting the SSL_CERT_FILE environment variable and a JVM option restored successful artifact uploads.
This guide walks through Kubernetes Service concepts, creation methods via kubectl expose and YAML, service inspection, endpoint management, and three ways to expose services externally—NodePort, LoadBalancer, and Ingress—plus detailed deployment options, TLS configuration, and practical command‑line examples.
This article explains how HTTPS works by detailing the certificate verification and data transmission phases, the use of asymmetric and symmetric encryption, the role of Certificate Authorities, potential man‑in‑the‑middle attacks, browser validation steps, and why HTTPS does not fully prevent packet capture.
The article explains the fundamental differences between HTTP and HTTPS, outlines how HTTPS adds SSL/TLS encryption to the standard HTTP protocol, describes the step‑by‑step communication process—including certificate verification, key exchange, and encrypted data transfer—and compares ports, security, and connection details.
This article demonstrates how to capture and analyze MySQL traffic on both unencrypted MySQL 5.7 and TLS‑encrypted MySQL 8.0 using tcpdump and Wireshark, explains the differences in packet contents, and walks through the TLS handshake process in detail.
This guide walks through the concepts and step‑by‑step procedures for using Kubernetes 4‑layer Service load balancing, configuring Ingress Controllers (nginx, Traefik), generating TLS certificates, deploying Traefik and a Tomcat application, and exposing them via HTTP and HTTPS.
The article explains Envoy's circuit‑breaking mechanisms, global rate‑limiting integration, and TLS support, detailing configuration options, limits, and example YAML snippets for deploying secure and resilient service‑mesh proxies.
This article explains why HTTPS was created to address HTTP’s lack of encryption, authentication, and integrity, describes how TLS/SSL adds security, details the roles of symmetric and asymmetric encryption, hash algorithms, digital certificates, and the full handshake process that secures modern web communication.
This article explains how HTTPS protects data through encryption and identity authentication, describes symmetric and asymmetric algorithms, outlines PKI and certificate issuance processes, demonstrates Nginx certificate deployment, and shows how trust chains and cross‑certificates ensure reliable secure connections.
This article explains the fundamentals of HTTPS by clarifying HTTP, SSL/TLS, and encryption types, describing HTTP's relationship with TCP and connection models, and outlining HTTPS's compatibility, extensibility, confidentiality, integrity, authenticity, and performance considerations.
This guide explains how to use JDK's keytool to create a self‑signed HTTPS certificate, configure Spring Boot to serve over HTTPS, set up HTTP‑to‑HTTPS redirection, and verify the setup with sample controller code and runtime logs.
This article presents a comprehensive guide to HTTP performance optimization, covering encoding efficiency, channel utilization, transport path enhancements, and security improvements, enabling developers and operators to reduce latency, save bandwidth, and handle massive concurrency effectively.
The article outlines four key dimensions for extreme HTTP performance optimization—encoding efficiency, channel utilization, transmission path, and information security—explaining how advances like binary encoding, multiplexed streams, TCP/QUIC tuning, and TLS 1.3 together reduce latency, boost concurrency, and enhance user experience.
The Apache Dubbo 2.7.5 release introduces application‑level service registration, native HTTP/2 (gRPC) and Protobuf support, a 30% performance uplift, TLS security, an optimized consumer thread‑pool, a new Bootstrap API, multi‑registry load balancing, and numerous other enhancements aimed at cloud‑native microservice development.
This article thoroughly explains how HTTPS ensures secure communication by detailing its certificate verification, the use of asymmetric encryption for authentication and symmetric encryption for data transfer, the role of Certificate Authorities, common attacks like man‑in‑the‑middle, and why HTTPS alone cannot prevent all forms of packet sniffing.
This article explains why HTTPS is considered secure, details its underlying TLS handshake and data transmission process, clarifies the roles of asymmetric and symmetric encryption, the necessity of CA‑issued certificates, and discusses common misconceptions such as man‑in‑the‑middle attacks and packet capture.
Through a narrative of a college student and her mother whose chat is intercepted and altered by a hacker, the article illustrates why plain HTTP is vulnerable, explains the principles of symmetric and asymmetric encryption, TLS/SSL, and how certificates and hybrid encryption secure modern communications.
This article explores how HTTPS certificates are validated, why revocation mechanisms like CRL and OCSP often fall short, compares browser implementations, and discusses practical mitigation techniques such as OCSP stapling and Must‑Staple to improve TLS security.
This article explains how HTTPS secures web communication by combining asymmetric certificate verification with symmetric data encryption, describes the role of Certificate Authorities, outlines the handshake process, discusses man‑in‑the‑middle attacks, and clarifies the limits of HTTPS against packet capture.
This article reconstructs the design of HTTPS step by step, explaining why both symmetric and asymmetric encryption are required, how key negotiation works, the role of digital certificates and certificate authorities, and the underlying security concepts that protect client‑server communication.
This article reconstructs the design of HTTPS by starting from a simple secure chat, explaining why symmetric encryption alone cannot secure web traffic, introducing asymmetric encryption for key exchange, detailing how digital certificates and certificate authorities solve public‑key distribution, and summarizing the TLS handshake process.
This article walks through the design of HTTPS, showing how symmetric encryption secures data while asymmetric encryption safely negotiates keys, and explains the role of digital certificates and certificate authorities in preventing man‑in‑the‑middle attacks.
This guide explains why Java HTTPS requests can fail with an SSLHandshakeException, covering the JCE unlimited‑strength policy replacement and TLS version mismatches, and provides complete code snippets for creating a permissive SSLContext and a pooled HttpClient to resolve the issue.
This article explains what HTTPS is, why it adds encryption to HTTP, how SSL/TLS, symmetric and asymmetric cryptography, certificates, and handshakes work together to ensure confidentiality, integrity, and authenticity, and discusses the performance impact of HTTPS connections.
This article provides a comprehensive walkthrough of using Go's crypto library for hashing, symmetric and asymmetric encryption, certificate generation, and TLS/HTTPS server and client implementation, illustrating how these techniques are applied in kubeadm to simplify Kubernetes cluster security.
HTTPS combines HTTP with SSL/TLS encryption to protect data transmission, involving DNS lookup, TCP three‑way handshake, TLS negotiation with certificates and symmetric keys, and finally encrypted HTTP communication, while the article also explains TCP’s four‑way termination and the overall request‑response flow.
This guide explains how to obtain a free wildcard HTTPS certificate from Let's Encrypt using the acme.sh tool in DNS manual mode, covering installation, issuing with DNS TXT records, renewal, and configuring the resulting fullchain and key files for web servers.
By instrumenting every C++ function with GCC’s ‑finstrument‑functions and recording call addresses in per‑thread TLS, the team built a fast, lock‑free stack‑trace mechanism that outperforms libunwind by up to 60×, integrates with Android’s malloc_debug, and powers an automated native‑memory‑leak detection framework with web‑based analysis.
The article explains the security risks of plain HTTP, introduces symmetric and asymmetric encryption, describes digital certificates, certificate authorities, digital signatures, and how they combine in HTTPS to protect data confidentiality, integrity, and authenticity during web communication.
HTTPS secures web communication by combining symmetric and asymmetric encryption, digital certificates, and signatures, addressing HTTP’s confidentiality, integrity, and authenticity flaws; the article explains these cryptographic concepts, the SSL/TLS handshake steps, and when HTTPS is appropriate despite its performance overhead.
This article demonstrates how to build a minimal HTTP/2 server in Go that responds only with header frames, covering certificate generation, server code, frame structures, the http2Framer API, and how to test the implementation using curl, providing both conceptual explanations and full source listings.
Using a vivid Journey to the West allegory, this article walks through cloud networking fundamentals—from regions, availability zones, and VPCs to BGP routing, DNS resolution, TCP handshakes, TLS encryption, load balancing, and micro‑service communication—illustrating each concept with clear diagrams and analogies.
This article explains the HTTPS handshake, the role of CA and root certificates, how trust chains work, and provides a step‑by‑step guide to using Fiddler for HTTPS decryption on Android, including OpenSSL commands for extracting public keys.
The Baidu App reduces connection latency by cutting TLS and TCP round‑trips through session resumption, False Start, pre‑connect, backup and composite connections, and automatic rebuilds, achieving 12‑16 % faster text and image loads and modest success‑rate gains across Android and iOS.
This article reconstructs the design of HTTPS by explaining why symmetric encryption, asymmetric encryption, random numbers, digital certificates, and certificate authorities are combined to securely negotiate a shared secret between a client and a web server, while addressing man‑in‑the‑middle attacks and certificate validation.
This article explains what HTTPS is, why it is needed, how TLS handshakes secure communication using asymmetric and symmetric encryption, the role of digital certificates and trust chains, methods of certificate revocation, and how to choose appropriate cipher suites for optimal security and performance.
This article explains why HTTPS is essential by comparing HTTP’s performance drawbacks, detailing its security vulnerabilities, and describing the cryptographic mechanisms—including TLS, symmetric and asymmetric encryption, certificates, and HMAC—that HTTPS employs to protect data and enable modern features like HTTP/2.
This article demonstrates how to build an HTTP/2 server and client in Go, covering TLS certificate generation, server and client implementations, switching between HTTP/1.1 and HTTP/2, server‑push handling, and full‑duplex echo communication with complete code examples.
This article explains the SSL/TLS handshake process, the role of private keys, the advantages of switching to Diffie‑Hellman, and how session IDs and tickets enable secure session resumption, illustrating each step with clear diagrams.
This article walks through upgrading Consul to 1.2, configuring service‑mesh support, building two Go micro‑services, registering them with Consul, reloading the configuration, testing the mesh with curl, and provides a detailed analysis of Consul’s service‑mesh architecture, advantages, and limitations.
This article explains the fundamentals of HTTPS by clarifying key terms such as HTTP, SSL/TLS, and encryption, describing how HTTP works over TCP, the differences between symmetric and asymmetric cryptography, and the core security requirements of confidentiality, integrity, authenticity, and performance.
This article describes the motivation, layered architecture, protocol implementation details, and a plug‑in refactoring approach for a cross‑platform long‑connection component that unifies iOS, Android, and WebSocket communication using libuv, mbedTLS, and C interfaces.
This article walks through a reconstructed design process of HTTPS, explaining why secure web communication requires both symmetric encryption for data transfer and asymmetric encryption plus digital certificates for key exchange and authentication, while demystifying each component with clear diagrams.
This article explains how to reduce the time users wait for the first screen by optimizing DNS resolution, TCP and TLS handshakes, HTTP protocols, resource loading, and rendering processes, while also covering related network and security considerations.
This article walks through a step‑by‑step reconstruction of HTTPS design, showing why secure communication requires per‑client symmetric keys negotiated via asymmetric encryption, digital certificates from trusted CAs, and how signatures and random numbers protect against man‑in‑the‑middle attacks.
This article explains what HTTPS is, why encrypting HTTP traffic is essential, how symmetric and asymmetric encryption protect data, the role of certificates and public‑key infrastructure, and the performance impact of the HTTPS handshake, providing a concise Q&A guide for beginners.
This article explains the fundamentals of HTTPS, covering why encryption is needed, how symmetric and asymmetric cryptography work together, the role of certificates and public‑key infrastructure, and the performance impact of the TLS handshake, all through a concise Q&A format.
This article explains what a Man‑in‑the‑Middle (MITM) attack is, illustrates it with a classic mailbox analogy, and describes how HTTPS, digital certificates, and the HSTS policy work together to prevent such attacks and ensure secure web communications.
This article investigates an intermittent timeout issue caused by a Java Apache HttpClient implementation that leaks connections, explains why numerous RST packets appear during TLS shutdown, and presents experiments and code revisions that clarify the TCP/TLS interaction and proper resource handling.
The article explains how Tengine 2.2.2 leverages Intel QuickAssist Technology to offload SSL/TLS operations via an async OpenSSL module, detailing its architecture, event‑driven workflow, and benchmark results that show up to 3.8× throughput improvement for HTTPS traffic.
This tutorial walks through preparing an Ubuntu host, installing Docker CE and Docker Compose, generating TLS certificates with acme.sh, downloading and configuring the Harbor registry, and finally pushing and pulling Docker images to verify a secure private Docker registry setup.
This article demystifies HTTPS by explaining its underlying encryption, signing, and certificate mechanisms, illustrating how zero‑knowledge proof concepts secure identity verification, and providing practical guidance on upgrading from HTTP, configuring certificates, capturing traffic with Fiddler, and understanding session recovery and performance considerations.
During a weekend project, we configured Apache Zeppelin to use HTTPS with a domain certificate, added optional mutual TLS, and modified its source code to restrict shell and Python execution, enabling the client’s security team to pass penetration testing while preserving Zeppelin’s core functionality.
This article presents a collection of straightforward, developer‑friendly techniques for enhancing Java API security and performance, covering API key protection, TLS adoption, Spring Boot web service creation, application monitoring, and safeguarding sensitive configuration files.
This article presents a comprehensive, data‑driven guide to reducing latency and increasing throughput of Nginx‑based web servers by covering hardware selection, low‑level OS tuning, network‑stack adjustments, TLS optimizations, and application‑level configurations, all illustrated with real‑world Dropbox experience.
This article explains why HTTPS is essential, compares third‑party and self‑managed TLS options, and provides a complete Go implementation using Let’s Encrypt’s autocert library, including code for certificate handling, HTTP‑to‑HTTPS redirection, DNS requirements, and caching strategies.
This guide explains why plain HTTP is insecure, introduces SSL/TLS fundamentals, compares certificate types, and provides step‑by‑step instructions for configuring HTTPS on a web server (including Nginx redirects), while highlighting performance impacts and testing considerations.
This article reviews the challenges of web performance, analyzes HTTP/1.1, HTTP/2, TLS, and QUIC protocols, discusses optimization techniques such as TCP fast open, TLS false start, server push, preconnect, and presents practical recommendations from the 2017 ArchSummit presentation.
This article recounts Stack Overflow’s multi‑year migration to HTTPS, detailing technical hurdles such as handling hundreds of domains, certificate management, HTTP/2 performance, HAProxy configuration, CDN integration, and the operational practices that ensured a secure and high‑performance global platform.
This guide compiles common HTTPS and HTTP/2 deployment problems—such as Let’s Encrypt validation failures, certificate transparency errors, SNI incompatibility, cipher‑suite misconfigurations, and mixed‑content issues—and provides concise, actionable solutions with reference links for each case.
This article explains the fundamental risks of plain HTTP, introduces HTTPS as a solution, and walks through the concepts of asymmetric encryption, digital signatures, certificate authorities, and the TLS handshake process using a relatable story of Bob and his friends to illustrate secure communication.
This article explains why HTTPS is considered secure, how it prevents man‑in‑the‑middle attacks through certificate verification, details the TLS handshake captured with Wireshark, and shows the cryptographic primitives behind RSA, ECDHE and AES, including practical code snippets and the cost of using HTTPS.
This guide explains how to deploy a private Docker Registry in Azure China using the open‑source azure‑docker‑registry‑template, covering architecture, required files, TLS configuration, ARM template parameters, and step‑by‑step deployment commands for creating certificates, storage, load balancer, and VM cluster.
This article explains why internet‑financial companies need encrypted MariaDB connections, shows how to verify SSL support, and provides a detailed eight‑step procedure—including OpenSSL upgrade, CA creation, server and client certificates, MySQL configuration, and verification—to enable secure client‑server communication.
This article reconstructs the design of HTTPS by starting from a simple chat scenario, explaining why both symmetric and asymmetric encryption are required, how key exchange and digital certificates work, and how the TLS handshake secures client‑server communication.
This article distills practical design decisions for modern encrypted communication protocols—covering algorithm selection, versioning, PKI choices, library alternatives, replay protection, performance tuning, and latency considerations—while providing a concise appendix of fundamental cryptographic concepts and key references.
This article surveys major TLS implementations, practical deployment and optimization strategies, and explores related modern encryption protocols such as QUIC, iMessage, HomeKit, TextSecure, OTR, and libsodium, providing resources and best‑practice guidance for secure communications.
This article provides a comprehensive security analysis of the TLS protocol, covering attacker models, authentication and key exchange mechanisms, version rollback attacks, handshake vulnerabilities, session resumption, application data protection, explicit IV concerns, DoS threats, session ticket security, TLS extensions, PKI considerations, historical flaws, and the major improvements introduced in TLS 1.3.
This article explains the TLS handshake process, covering server certificate transmission, server key exchange details, certificate request handling, server hello done, client certificate usage, client key exchange mechanisms, RSA premaster secret encryption, Diffie‑Hellman and ECDH key exchanges, and the certificate verify step.
This article explains the TLS handshake process, detailing the Finished message verification, the use of NewSessionTicket for stateless session resumption, and the roles of ChangeCipherSpec, Alert, and Application Data protocols in secure communications.
This article explains how the TLS record layer encrypts and authenticates application data by fragmenting, sequencing, optionally compressing, encrypting, computing HMAC, and transmitting over TCP/IP, while detailing the security parameters, key derivation, and the evolution from MAC‑then‑Encrypt to AEAD modes.
This article explains the layered design of TLS, details the cryptographic primitives and cipher suites it uses, and provides guidance on selecting secure configurations while avoiding unsafe legacy algorithms.
This article explains the TLS handshake protocol in depth, covering its overall flow, the generation of security parameters, the role of asymmetric algorithms, message structures, performance considerations, and mechanisms like session caching and abbreviated handshakes to ensure secure communication.
This article explores the TLS protocol in depth, outlining its design objectives, cryptographic foundations, historical evolution, detailed handshake and record layer mechanisms, security analyses, common pitfalls, and lessons for designing robust modern encrypted communication protocols.
This tutorial walks you through installing required packages, compiling LZO and OpenVPN, configuring environment variables, generating CA, server and client certificates, packaging client files, adjusting server and client configuration files, and finally starting the OpenVPN service on a Linux host.
Next Wednesday the Node.js team will release security updates for several versions, fixing critical TLS certificate handling flaws and other vulnerabilities, while announcing the end of maintenance for the v0.10.x line and urging users to upgrade to newer releases.
This article explains Chrome's green‑yellow‑red HTTPS indicators, the pitfalls of SHA‑1 certificates, mixed‑content warnings, AES key size choices, and provides concrete Nginx configuration snippets to upgrade to SHA‑2 and modern cipher suites.
This article explains why migrating to HTTPS is critical for modern web applications, outlines the technical challenges such as compatibility, latency, and attacks, and details Baidu's practical solutions and free options for small sites to adopt full‑site HTTPS securely and efficiently.
This guide walks you through obtaining a free Let’s Encrypt certificate, installing it on typical hosting platforms, fixing common private‑key issues, verifying the setup, and enforcing HTTPS for all requests, all in under half an hour.
This article explains the fundamentals of HTTPS by comparing web communication to passing notes in a classroom, covering symmetric and asymmetric encryption, RSA key exchange, the role of Certificate Authorities, and how these mechanisms together protect against man‑in‑the‑middle attacks.
mmtls is a custom, lightweight secure communication protocol designed for WeChat that encrypts all client‑to‑server traffic, offering confidentiality, integrity, low latency, scalability, and forward secrecy by adapting TLS 1.3 concepts with optimized handshake, key‑exchange, record, and replay‑protection mechanisms.
