This article explains how to secure data transmission in PHP by using HTTPS, symmetric encryption algorithms like AES, and asymmetric encryption with OpenSSL, including code examples and key management recommendations for web applications.
This article explains why encrypting data transmission is essential, then demonstrates three PHP-based methods—enabling HTTPS via SSL/TLS, applying symmetric algorithms such as AES, and using asymmetric encryption with OpenSSL—to protect confidentiality, integrity, and authentication of web communications.
This article explains why encrypting data transmission is essential, then demonstrates how to secure PHP-based communications using HTTPS, symmetric algorithms such as AES, and asymmetric encryption with OpenSSL, including complete code examples and key management tips.
This article presents a comprehensive API encryption scheme that combines symmetric and asymmetric cryptography, hashing, and digital signatures, explains HTTPS fundamentals, details WeChat Pay encryption, outlines key exchange and data protection processes, provides Java code examples, and analyzes security, anti‑tampering, anti‑replay, and performance considerations.
This article explains the fundamentals of symmetric and asymmetric encryption, how digital signatures and HTTPS work with certificate authorities, and demonstrates a practical implementation of secure URL encryption, key exchange, and request validation using custom Spring Cloud Gateway filters written in Java.
This article explains the fundamentals of the HTTP protocol, illustrates its susceptibility to man‑in‑the‑middle attacks, discusses symmetric and asymmetric encryption attempts, and then details how HTTPS (TLS) and the CA trust model protect data transmission from interception and tampering.
This article walks through a complete API protection scheme that combines HTTPS fundamentals, symmetric AES encryption, RSA key exchange, SHA‑256 hashing, and custom signature logic to prevent crawling, request tampering, and replay attacks while maintaining high performance.
When running Jenkins inside a Docker container on a VM, HTTPS requests to accounts.google.com time out due to an MTU mismatch between the host and the container, which can be resolved by adjusting the MSS via iptables or setting a lower MTU for Docker interfaces.
This guide explains how to troubleshoot a Java SSLHandshakeException caused by an untrusted third‑party HTTPS endpoint when fetching PDF files, covering certificate installation, trustStore configuration, and a custom TrustManager solution to bypass verification.
This article presents a comprehensive design and implementation guide for securing API interfaces by combining HTTPS fundamentals with WeChat Pay encryption techniques, detailing symmetric and asymmetric encryption, hashing, signature verification, key exchange, parameter handling, and backend processing to protect against tampering, replay attacks, and data leakage.
The article walks through diagnosing a Java SSLHandshakeException caused by an untrusted HTTPS certificate when fetching a PDF, and presents three solutions: using InstallCert to add the certificate, configuring trustStore properties, and finally bypassing verification with a custom TrustManager and HostnameVerifier.
This article walks through eight concrete techniques—firewall rules, captchas, authentication checks, IP whitelists, HTTPS encryption, rate limiting, monitoring, and an API gateway—to prevent abusive requests from draining resources or compromising critical services.
HTTPS secures web traffic by combining symmetric and asymmetric encryption, digital signatures, and certificate authorities within the TLS protocol to ensure confidentiality, integrity, authentication, and non‑repudiation, replacing insecure HTTP and becoming mandatory for modern browsers, servers, and platforms despite earlier concerns about cost and complexity.
HTTPS secures web communication by adding SSL/TLS encryption to HTTP, providing confidentiality, integrity, authentication, and non-repudiation through a combination of symmetric and asymmetric cryptography, hash functions, digital signatures, and certificate authorities, while addressing migration concerns and performance considerations.
This guide explains why separate ports are normally required for multiple SSL sites, how Nginx’s SNI support lets you share a single IP and port, and provides step‑by‑step compilation and configuration examples for www, live, and vod domains.
This article outlines eleven practical techniques for protecting API endpoints, covering parameter validation, unified response wrapping, XSS escaping, captcha integration, rate limiting, IP whitelisting, sensitive‑word checks, HTTPS adoption, data encryption, and comprehensive risk control measures, each illustrated with concrete code snippets and step‑by‑step workflows.
By integrating Intel QuickAssist hardware and AVX‑512 software acceleration into the VUA component of Vivo’s load‑balancing platform, the article demonstrates asynchronous OpenSSL offloading that boosts HTTPS forwarding throughput to roughly 44 000 QPS with QAT cards and 51 000 QPS with software, while preserving scalability and security.
This article explains common login security risks such as brute‑force cracking, CAPTCHA bypass, IP‑based blocking, man‑in‑the‑middle attacks, and shows practical countermeasures like captcha enforcement, login throttling, phone verification, HTTPS adoption, and data encryption.
This guide walks through installing Nginx and Java on CentOS, deploying a Spring Boot JAR, obtaining a free FreeSSL.cn certificate with acme.sh, configuring Nginx for HTTP‑to‑HTTPS redirection and SSL, and enabling automatic three‑month renewal via the built‑in cron job.
This article examines common login vulnerabilities such as brute‑force attacks, CAPTCHA bypass, IP‑based lockouts, and man‑in‑the‑middle threats, and provides practical mitigation techniques—including password‑retry limits, CAPTCHA, SMS verification, HTTPS enforcement, and logging—to harden web authentication systems.
Chrome is trialing an HTTPS‑First approach that automatically upgrades insecure HTTP requests, warns about risky downloads, and gradually rolls out secure‑by‑default settings, aiming to protect the majority of web traffic from eavesdropping and tampering.
This article explains how to protect data transmission in PHP applications by employing HTTPS (SSL/TLS), implementing symmetric encryption such as AES, and using asymmetric encryption with OpenSSL, while highlighting key management practices to ensure confidentiality, integrity, and resistance to man‑in‑the‑middle attacks.
This article explains why HTTPS is needed, defines the protocol, describes the four security properties—confidentiality, integrity, authentication, and non‑repudiation—covers symmetric and asymmetric encryption, hybrid encryption, hash functions, digital signatures, certificate authorities, and the trust chain that together protect web communications.
This guide walks you through obtaining a valid SSL certificate, installing Nginx on a Linux server, configuring the HTTPS server block, converting certificates to PEM format, and testing the secure connection, providing step‑by‑step commands and example configurations.
This article walks through the entire browser request lifecycle—from entering a URL, resolving the IP via caches and DNS, establishing a secure HTTPS connection, to the server’s response and the browser’s parsing of HTML, CSS, and JavaScript into a rendered page.
This article reviews why HTTPS certificate expiration checks are often missed and introduces several open‑source monitoring tools—including blackbox_exporter, EaseProbe, uptime‑kuma, domain‑admin, and a simple shell script—to help operations teams ensure timely certificate renewal.
HTTPS protects online communications by combining TLS encryption, digital certificates, and cryptographic techniques such as symmetric and asymmetric encryption, hash functions, and certificate authorities, ensuring confidentiality, integrity, authentication, and non‑repudiation, while addressing key exchange, trust chains, and common security pitfalls.
This article walks through the complete browser workflow—from entering a URL and resolving it via DNS caches and recursive lookup, through establishing a secure HTTPS connection with TCP handshakes and key exchange, to the server's response and the browser's rendering process.
This article reviews five widely used encryption algorithms—MD5, SHA‑256, DES, AES, and RSA—explaining their classifications, Java implementations, strengths, weaknesses, and how they combine in HTTPS to secure data transmission.
This article explains how to secure PHP APIs by implementing a signature mechanism and rate‑limiting using Redis, and also outlines additional protections such as HTTPS, access control, input validation, logging, and security audits.
This article explains how to use Lua scripts for performance testing by providing reusable functions that encapsulate HTTP and HTTPS GET/POST requests, support JSON and FormData payloads, and enable file uploads, complete with full code examples.
Chrome’s new HTTPS‑First experiment automatically upgrades HTTP requests to HTTPS, warns about insecure downloads, and rolls out gradually, aiming to make the web safer by encrypting the majority of traffic while still handling edge cases gracefully.
Chrome’s latest experiment aims to automatically upgrade all HTTP requests to HTTPS, detailing current HTTPS adoption rates, the new HTTPS‑First mode’s automatic upgrades, unsafe download warnings, phased rollout plans, and how users can enable the feature now for a more secure browsing experience.
This article explains why backend developers should switch from HTTP to HTTPS for user-facing services, highlights the key differences—including SSL and TLS—and points to a concise five‑minute video that visually demonstrates how HTTPS works and secures web traffic.
This article explains how to secure PHP communications using HTTPS by obtaining SSL certificates, configuring cURL options, creating requests, verifying server certificates, and handling SSL errors, with complete code examples for developers.
This tutorial explains digital certificate fundamentals, common formats, the principles of one‑way and two‑way HTTPS authentication, and provides step‑by‑step Kubernetes configurations—including secret creation and Ingress setup—to implement secure TLS communication.
Even though HTTPS encrypts web traffic, DNS queries, IP address sharing, traffic patterns, cookies, and especially the plaintext TLS handshake—including the SNI field—can reveal which sites you visit, but the Encrypted ClientHello extension can mitigate this leakage.
This guide explains three ways to generate SSL certificates using OpenSSL, including creating a private key, self‑signed certificate, and CSR‑based signing, and shows how to configure Nginx to enable HTTPS with the generated certificates.
Although you can obtain a website’s IP address, accessing it directly via HTTPS often fails because the HTTP request’s Host header differs, and servers use this header to verify the intended domain, leading to 403 errors unless the correct Host value is supplied.
The article explains why visiting a website by its IP address often results in errors, showing that the HTTP Host header differs from domain‑based requests, and demonstrates this with Fiddler and Postman experiments using Baidu as an example.
This article provides a comprehensive guide to essential Nginx configurations—including reverse proxy, static file serving, HTTPS, load balancing, caching, URL rewriting, response headers, gzip compression, SSL redirection, scheduled tasks, security, logging, and basic authentication—to improve the efficiency and stability of interface automation testing.
This article explains why and how to upgrade an HTTP website to HTTPS, introduces the differences between the protocols, compares paid and free CA certificates, and provides a step‑by‑step tutorial for installing, issuing, installing, and automatically renewing certificates with the acme.sh script.
This article explains how to use Node.js's built‑in http/https modules to call third‑party APIs and demonstrates three concurrency techniques—Promise.all, async/await with Promise.race, and EventEmitter—to perform parallel requests efficiently, including code examples for constructing requests, handling responses, and error management.
This article explains how to protect PHP‑based API endpoints by using request signatures, nonce and timestamp validation, Redis‑backed rate limiting, and additional best practices such as HTTPS, access control, input validation, logging, and security audits.
This guide walks you through installing Nginx Proxy Manager via Docker, configuring its web UI, setting up a reverse proxy for the admin panel, and securing it with a Let's Encrypt SSL certificate, all without needing deep Nginx knowledge.
This article explains the fundamental weaknesses of HTTP, demonstrates how man‑in‑the‑middle attacks exploit clear‑text communication, and shows how HTTPS—through SSL/TLS handshakes, certificate validation, and CA hierarchies—protects web traffic from interception and tampering.
This article explains why an Nginx reverse‑proxy configuration that proxies HTTPS requests to a backend server causes the browser URL to change, how to fix the redirect by using HTTPS in the proxy, and how to achieve session consistency across multiple Tomcat instances by deploying Memcached with Docker and adjusting Tomcat’s session manager.
This article explains the fundamentals of HTTP, demonstrates how its plaintext nature enables man‑in‑the‑middle attacks, explores symmetric and asymmetric encryption attempts to mitigate the risk, and shows how HTTPS—through TLS handshakes, certificate validation, and a trusted CA hierarchy—provides robust protection.
This article explains why HTTPS provides stronger security than HTTP by detailing symmetric and asymmetric encryption, integrity hashing, digital certificates, and the SSL/TLS handshake process, illustrating how each component protects data from eavesdropping, tampering, and impersonation.
This article explains why HTTP is insecure, how HTTPS uses encryption, integrity checks, digital certificates, and a hybrid of symmetric and asymmetric cryptography, and details the SSL/TLS handshake process that secures data transmission over the web.
This article details how an Android team unified multiple network libraries into OkHttp, integrated HttpDns to bypass carrier DNS hijacking, migrated to HTTPS and HTTP/2, and applied a series of performance and security optimizations that markedly improved request speed, reliability, and user experience across diverse mobile network conditions.
This article explains why HTTPS provides secure communication by detailing the TLS handshake, the roles of asymmetric and symmetric encryption, the necessity of CA‑issued certificates, how browsers validate them, and the limits of HTTPS against man‑in‑the‑middle attacks.
This article provides an in‑depth tutorial on Nginx, covering installation on Linux, core configuration directives, server name and location matching, reverse proxy setup, various load‑balancing algorithms, caching strategies, HTTPS setup, CORS handling, gzip compression, and an overview of Nginx's process architecture and module system.
An in‑depth guide explains the difference between symmetric and asymmetric encryption, why a public key can encrypt but not decrypt, and walks through the TLS 1.2 handshake that underpins HTTPS, covering certificates, random numbers, session key derivation, and the role of public‑private key pairs.
This guide walks through capturing Baidu.com packets using ping, tcpdump, and Wireshark, explains why HTTPS traffic is invisible to simple filters, and shows how to decrypt it by exporting TLS keys with SSLKEYLOGFILE and configuring Wireshark to reveal the encrypted data.
This article walks through the complete process of acquiring a free SSL certificate, exporting it as a PFX file, and configuring the server settings to enable HTTPS for a mini‑program, while highlighting common pitfalls and required tools.
The article surveys the evolution of web communication from HTTP/1.x through HTTPS, HTTP/2, and HTTP/3, explaining request/response structure, methods, status codes, URIs, connection handling, cookies, caching, TLS encryption, and the performance‑boosting features of header compression, multiplexing, and QUIC‑based transport.
This guide introduces Caddy 2, an enterprise‑grade Go‑based web server, outlines its key features and advantages over Nginx, provides step‑by‑step installation commands for various Linux distributions and macOS, and demonstrates comprehensive Caddyfile configurations including site blocks, global options, logging, TLS, reverse proxy, and modular snippets.
This guide shows how to enable HTTPS on Nginx by either obtaining a free Alibaba Cloud SSL certificate—generating a CSR, submitting it, and configuring the server—or creating a self‑signed OpenSSL certificate with custom SANs, installing it, updating hosts, and verifying the secure connection.
This article examines the inherent security flaws of plain HTTP, proposes four solution approaches, and explains why the fourth—combining digital certificates, asymmetric and symmetric encryption—forms the basis of HTTPS, then details TLS 1.2 handshake steps, cryptographic primitives, and practical implementation considerations.
This guide walks through creating a self‑signed SSL certificate with JDK’s keytool, configuring Spring Boot to use the PKCS12 keystore, redirecting HTTP to HTTPS, and alternatively obtaining a free FreeSSL certificate, covering necessary code, configuration files, and deployment steps for both Windows and Linux environments.
This article explains the HTTPS protocol, its security advantages over HTTP, and provides a step‑by‑step Wireshark packet capture and analysis of a test website, covering TCP three‑way handshake, TLS ClientHello/ServerHello, certificate verification, key exchange, and encrypted data transmission.
The article explains why browsers like Chrome 94 block cross‑origin requests from public contexts to private‑network resources, illustrates the issue with a reproducible example, analyzes the underlying policy changes, and provides practical solutions and configuration steps to mitigate the problem.
The article explains that HTTPS does encrypt the full HTTP request—including the URL—by encrypting both headers and body, while the domain name can still be seen in the TLS handshake via SNI, and it details how TLS record protocol ensures data integrity through MAC and encryption.
This guide walks through obtaining a free SSL certificate, exporting it as a PFX file, and configuring IIS with the appropriate server settings to enable HTTPS for a mini‑program, while highlighting common pitfalls and required client tools.
To achieve sub‑second start‑up for mobile video streaming, the iQIYI overseas project applies layered HTTPS optimizations—including DNS and certificate caching, ECDHE/X25519 key exchange, false start, lightweight cipher suites, ECDSA certificates, OCSP stapling, and session‑ID/ticket reuse—while transitioning toward TLS 1.3 0‑RTT and HTTP/3 QUIC for further latency reduction.
This article explains the fundamentals of HTTP and HTTPS, covering the protocol structure, common request methods, request and response message formats, differences between GET and POST, response status code categories, a full HTTP transaction flow, and the encryption mechanisms and drawbacks of HTTPS.
This article explains the fundamentals of HTTP and HTTPS, covering the protocol structure, common request methods, differences between GET and POST, the full lifecycle of an HTTP request, and how HTTPS adds encryption, authentication, and its trade‑offs.
This guide walks through obtaining a free SSL certificate, exporting it from the provider, and configuring a Spring Boot application to use the certificate, including detailed steps, screenshots, and the necessary server.yml configuration.
This article explains the fundamentals of HTTP and HTTPS, covering request and response structures, common methods, differences between GET and POST, response codes, the complete request flow, and how HTTPS adds SSL/TLS encryption for secure communication.
This article explains how HTTPS combines HTTP with SSL/TLS, walks through the TLS handshake steps, describes symmetric and asymmetric encryption, the role of X.509 certificates, digital signatures, certificate chains, and provides a hands‑on OpenSSL guide for manually verifying a server certificate.
This curated list presents a selection of recent technical articles covering web performance optimization, a high‑performance Web graphics engine, new Node.js 18 features, HTTPS security fundamentals, Vue performance tips, Service Worker basics, React libraries, and creative CSS techniques.
This article explains the evolution from HTTP to HTTPS, detailing HTTP’s history, its security shortcomings, the principles of symmetric and asymmetric encryption, digital signatures, certificate authorities, and the complete HTTPS handshake process, helping readers understand how secure web communication works.
This guide walks through downloading DTLE, generating a self‑signed SSL certificate, configuring Nomad with the certificate and key, starting the DTLE services, and verifying HTTPS access to securely protect database credentials during data transfer.
This guide details the step‑by‑step process of obtaining a free SSL certificate, exporting it, and configuring the server with the appropriate key‑store settings to enable HTTPS for a mini‑program, including tips on common pitfalls and verification methods.
This article provides a comprehensive overview of the HTTP protocol, covering its fundamental concepts, request methods, status codes, common headers, caching mechanisms, security differences with HTTPS, and the evolution of the protocol through HTTP/1.1, HTTP/2, and HTTP/3.
This article provides a detailed tutorial on installing Caddy on CentOS and Docker, configuring its powerful Caddyfile syntax, enabling HTTPS, reverse and forward proxy, gzip compression, address rewriting, and directory routing, demonstrating how Caddy can replace Nginx for modern web hosting.
This article explains how everyday network protocols such as DNS, HTTP, and IP routing expose your traffic to eavesdropping, hijacking, and spoofing, and it reviews practical mitigations like DNSSEC, DoH, ODoH, TLS 1.3, HSTS, and user‑focused security hygiene.
This guide walks you through applying for a free SSL certificate, exporting it as a PFX file, and configuring Spring Boot to serve HTTPS on port 443, including code snippets and common pitfalls to avoid.
A developer recounts a frustrating exchange with an Alibaba Cloud support engineer over missing images, explains why HTTPS CDN links failed, and shares a step‑by‑step workaround using HTTP links and OSS to restore image accessibility for GitHub‑hosted sites.
This article walks through the TLS handshake, explains how client and server derive symmetric keys and MAC secrets, illustrates the encryption process, and shows why the sequence number in TLS MAC calculations prevents replay attacks, answering whether HTTPS can block such attacks.
This guide explains why and how to migrate an HTTP website to HTTPS, covering the differences between the protocols, options for obtaining SSL certificates, step‑by‑step installation of the acme.sh script, generating, installing, and automatically renewing certificates using both HTTP and DNS validation methods.
This article examines common security risks such as brute‑force attacks, CAPTCHA bypass, login throttling, IP blocking, man‑in‑the‑middle threats, and outlines practical mitigation techniques including CAPTCHA, rate limiting, IP restrictions, mobile verification, HTTPS enforcement, and data encryption to harden web login functionality.
This article explains why password security is critical, describes symmetric and asymmetric encryption methods, details how HTTPS and RSA protect data in transit, and outlines best practices for securely storing passwords using hashing, salting, BCrypt, and PBKDF2.
This article explains the fundamentals of the HTTP protocol, illustrates how plain‑text communication enables man‑in‑the‑middle attacks, and describes how symmetric and asymmetric encryption, SSL/TLS handshakes, and CA certificate chains are used in HTTPS to secure web traffic.
This article compiles a series of backend interview questions covering HTTP header fields, HTTPS handshake, TCP connection states, virtual and physical memory concepts, TCP connection limits, Eureka architecture and consistency, Hystrix fault‑tolerance mechanisms, Zookeeper's Zab protocol and leader election, and provides a Java solution for finding the longest substring without repeating characters.
This comprehensive guide answers 19 core networking interview questions, covering the TCP/IP five‑layer model, HTTP fundamentals, GET vs POST, ping, status codes, differences among HTTP/1.0, 1.1, 2, 3, HTTPS, TCP connection handshake and teardown, sliding windows, flow control, half‑ and full‑connection queues, packet framing, and the browser request lifecycle.
Designing a login interface requires not only functional implementation but also comprehensive security measures such as protecting against brute‑force attacks, implementing captchas, login throttling, IP restrictions, mobile verification, and mitigating man‑in‑the‑middle threats, while balancing usability and system robustness.
This article explains how HTTPS uses SSL/TLS to encrypt data, authenticate servers, and protect integrity, then examines the handshake process, certificate authority verification, man‑in‑the‑middle attacks, and why HTTPS alone cannot guarantee absolute security.
This article examines common security vulnerabilities in web login processes, demonstrates how plain‑text passwords can be intercepted over HTTP/HTTPS, evaluates symmetric and asymmetric encryption, discusses the limitations of MD5, and proposes token‑based and digital‑signature solutions to protect credentials and data integrity.
This article explains why HTTP lacks confidentiality, introduces symmetric, asymmetric, and hybrid encryption, describes the HTTPS handshake steps, and shows how Apache HttpClient builds SSL connections with code examples, highlighting key components such as SSLConnectionSocketFactory and HostnameVerifier.
The article explains the key differences between HTTP and HTTPS—including transmission security, connection methods, port numbers, and certificate requirements—and describes how HTTPS uses SSL/TLS, public‑key cryptography, and session keys to guarantee secure data exchange.
This article examines common security flaws in basic HTML login forms, demonstrates how plaintext passwords can be intercepted over HTTP, evaluates symmetric and asymmetric encryption, discusses the limitations of HTTPS, and proposes practical safeguards such as MD5 hashing, token-based authentication, captchas, and digital signatures to protect user credentials.
This article walks through the concepts, protocols, and complete Go code needed to implement both HTTP and HTTPS forward proxies, explaining request handling, header transformations, and TCP forwarding while providing clear diagrams and runnable examples.
This article walks through a step‑by‑step reconstruction of HTTPS’s design, explaining why both symmetric and asymmetric encryption are needed, how key exchange is negotiated, and how digital certificates and signatures solve the trust problem in secure web communication.
This article compares token-based and signature-based API authentication methods, discusses their advantages and drawbacks, and provides complete Java code examples—including JWT token utilities, authentication interceptors, and signature verification—to help developers implement robust API security in real-world projects.
This article provides a detailed introduction to Nginx, covering its architecture, core configuration directives, installation steps, reverse proxy and load‑balancing setups, caching, HTTPS, CORS handling, gzip compression, and practical examples to help developers and operations engineers configure and use Nginx effectively.
This article explains the fundamental concepts of HTTPS, covering TLS/SSL algorithms, the roles of symmetric and asymmetric encryption, digital signatures, certificate authorities, the TLS 1.2 handshake process, and why HTTPS is preferred over HTTP despite deployment challenges.
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 mechanisms that protect client‑server communication.
This article explains practical security measures for login interfaces, covering brute‑force attacks, captcha integration, IP throttling, mobile verification, man‑in‑the‑middle protection with HTTPS, and additional best‑practice recommendations to harden web back‑end authentication.
