Version 25.1 of Erlang/OTP, the first maintenance patch for OTP 25, introduces production‑ready OpenSSL 3.0 crypto support, fixes a critical CVE‑2022‑37026 SSL/TLS client‑authentication bypass, adjusts engine loading behavior, and includes various minor bug fixes and enhancements.
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 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.
This article introduces the SSL protocol, explains why encryption is needed for database communication, and provides step‑by‑step instructions for generating self‑signed certificates with OpenSSL, converting them for Java, and configuring both DBLE server and client to use SSL, including experimental verification of encrypted versus unencrypted connections.
This article explains why the MySQL 8.0 client may report the caching_sha2_password authentication error requiring a secure connection, describes the plugin’s design, RSA and SSL mechanisms, cache behavior, and provides practical commands and replication settings to resolve the issue.
This guide walks through setting up the GitLab CE repository, installing GitLab, generating SSL certificates, configuring GitLab and Nginx for HTTPS, and verifying access on a CentOS server using command‑line operations.
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 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.
This article explains the differences between TLS and SSL, details the TLS handshake and certificate mechanisms, and provides step‑by‑step guidance for configuring encrypted connections on MySQL servers, clients, and JDBC drivers.
This cheat sheet compiles the most common Nginx configuration snippets—including listening ports, access logs, server names, static file serving, redirects, reverse proxy, load balancing, and SSL settings—providing a quick reference for developers and operators to set up high‑performance web servers.
This article provides a step‑by‑step tutorial on installing Nginx, setting up reverse‑proxy and various load‑balancing methods, configuring SSL, deploying Keepalived for failover, and building an LVS‑DR high‑availability cluster with detailed command examples and configuration snippets.
This tutorial walks through installing Nginx, setting up upstream reverse‑proxy rules, configuring various load‑balancing algorithms, enabling SSL, deploying Keepalived for failover, and building an LVS‑DR high‑availability cluster with detailed commands and configuration examples.
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 presents a concise Nginx cheat sheet covering common configuration blocks such as listening ports, access logs, server names, static file serving, redirects, reverse proxy, load balancing, and SSL settings, providing ready-to-use code snippets to help developers quickly set up and optimize their web servers.
This tutorial walks through installing Nginx from source, setting up upstream reverse‑proxy groups, configuring various load‑balancing methods (weight, IP hash, URL hash, least connections), enabling SSL, deploying Keepalived for failover, and building an LVS‑DR high‑availability cluster with detailed command‑line examples.
This article examines why MySQL benchmark results often show low transactions per second on seemingly powerful servers, exploring hidden factors such as network bottlenecks, SSL overhead, and inappropriate sort_buffer_size settings, and provides practical troubleshooting steps and configuration tweaks to achieve optimal performance.
This article compiles a practical Nginx cheat sheet covering listening ports, access logs, server names, static file serving, redirects, reverse proxy, load balancing, SSL settings, and a visual configuration tool, providing ready-to-use snippets for high‑performance web server setups.
This article provides a concise collection of frequently used Nginx configuration examples—including listening ports, access logs, server names, static assets, redirects, reverse proxy, load balancing, and SSL settings—to help developers quickly set up a high‑performance web server.
This article explains the security risks of early Internet protocols, the evolution of SSL/TLS and DTLS, fundamental cryptographic concepts such as symmetric and asymmetric encryption, hashing, MACs, digital signatures, AES modes and padding, and how these technologies are applied in TLS handshakes, DTLS, and WebRTC.
This article provides a concise collection of frequently used Nginx configuration snippets—including listening ports, access logs, server names, static assets, redirects, reverse proxy, load balancing, and SSL settings—along with a brief introduction to an online visual configuration tool.
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.
SSL/TLS protects internet traffic by encrypting data, verifying integrity, and authenticating parties, and this article outlines its purpose, historical evolution, core operation using public‑key and symmetric keys, and details each step of the handshake process that establishes a secure session.
This article provides a concise Nginx cheat sheet covering essential configuration snippets such as listening ports, access logs, server names, static assets, redirects, reverse proxy, load balancing, and SSL settings, along with links to an online visual configuration tool.
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 shares a developer’s journey from spending on domains and servers to mastering deployment, covering domain registration, DNS configuration, SSL, Linux commands, server panels, and how to monetize the skills while offering a step‑by‑step guide for newcomers to use a server effectively.
This guide explains how to download and run FastGithub, import its local HTTPS certificate, and resolve common Git SSL certificate verification errors by adjusting Git's SSL settings, providing step‑by‑step instructions and relevant code snippets.
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.
After upgrading MySQL Connector/J from 8.0.18 to 8.0.20 on IBM JDK 1.8, SSL handshake failures occur due to mismatched cipher suite naming, and the article details analysis of MySQL and IBM JSSE2 TLS settings, packet captures, and multiple remediation strategies including JVM parameters and JDK upgrades.
This article outlines ten actionable techniques—including reverse proxy deployment, load balancing, caching, compression, SSL/TLS optimization, HTTP/2 adoption, software upgrades, Linux tuning, web‑server tweaks, and real‑time monitoring—that together can boost a web application's speed and reliability by up to ten times.
This article compiles a concise Nginx cheat sheet covering common configuration blocks such as port listening, access logging, server name handling, static file serving, redirects, reverse proxy, load balancing, and SSL settings, plus a brief note on a visual configuration tool.
This article explains the four SSL session cache modes in Nginx, demonstrates with Wireshark captures how enabling the cache cuts TLS handshake time, and shows that reusing sessions can improve connection efficiency by roughly 40%.
This article presents a collection of frequently used Nginx configuration examples—including listening ports, access logs, server names, static assets, redirects, reverse proxy, load balancing, and SSL settings—to help developers quickly set up and customize their web server deployments.
This cheat sheet provides concise Nginx configuration examples covering listening ports, logging, domain handling, static file serving, redirects, reverse proxy, load balancing, and SSL setup, helping developers quickly configure a high‑performance web server.
This guide explains the fundamentals of etcd, its Raft‑based architecture, cluster planning, secure certificate generation, installation steps, service configuration, and verification commands to deploy a reliable, SSL‑protected etcd cluster for service discovery and configuration management.
The article explains the vulnerabilities of plain HTTP, demonstrates how man‑in‑the‑middle attacks can intercept and modify traffic, and describes the evolution of security mechanisms—including symmetric and asymmetric encryption, TLS handshakes, and certificate authority verification—that together make HTTPS a robust solution for protecting web communications.
This guide explains why and how to upgrade an HTTP website to HTTPS using free Let’s Encrypt certificates and the acme.sh script, covering installation, certificate generation via HTTP or DNS validation, deployment to Apache/Nginx, and automated renewal.
This article explains why low‑latency Nginx HTTPS is crucial for instant search, analyzes how TLS handshakes add round‑trip delays, and provides concrete Nginx TLS configuration changes—such as enabling HTTP/2, adjusting cipher suites, enabling OCSP stapling, tweaking buffer sizes and session caches—that together reduced request latency by about 30% in a real‑world deployment.
The article explains the vulnerabilities of plain HTTP, illustrates man‑in‑the‑middle attacks, shows why simple symmetric encryption is insufficient, and then details how HTTPS—built on SSL/TLS, asymmetric key exchange, and CA certificate validation—prevents these attacks, providing a comprehensive overview of secure web communication.
This guide explains how to generate self‑signed SSL certificates with OpenSSL, configure an Nginx reverse‑proxy container via Docker, install the root certificate on the host system, and modify the hosts file so that front‑end code can securely access a local HTTP service over HTTPS.
This guide explains why and how to migrate a website from HTTP to HTTPS by obtaining free Let’s Encrypt certificates, installing the acme.sh script, using HTTP or DNS validation, copying the certificates to the web server, and automating renewal and updates.
The nginx 1.19.4 mainline release adds new directives such as proxy_smtp_auth, several ssl_conf_command variants, and ssl_reject_handshake, with the latter allowing servers to reject SSL handshakes for specified hostnames, as demonstrated by example configuration snippets.
The NGINX 1.19.4 mainline release adds new SSL directives such as ssl_conf_command and ssl_reject_handshake, introduces a proxy_smtp_auth mail proxy feature, and provides configuration examples showing how to reject SSL handshakes for all server names except a specified one.
This article explains why HTTPS is required for secure data transmission, describes symmetric and asymmetric encryption, outlines the role of CA certificates, and provides step‑by‑step commands to generate keys, create certificates, and configure Nginx to serve HTTPS traffic.
This guide explains why you should switch from HTTP to HTTPS, compares the two protocols, shows how to obtain free or paid SSL certificates, and provides step‑by‑step instructions for installing and automating certificate issuance using the acme.sh script on Apache, Nginx or standalone servers.
This guide explains why and how to migrate an HTTP website to HTTPS by adding an SSL/TLS certificate, covering the differences between HTTP and HTTPS, options for obtaining free or paid CA certificates, installing the acme.sh script, generating and installing certificates, and handling updates and troubleshooting.
This tutorial explains how to use Python's requests and lxml libraries to crawl a website, bypass SSL verification, extract audio file URLs, and download sound effect MP3s in bulk, providing complete code snippets and practical tips for safe web scraping.
Understanding SSL certificates, their role in securing web traffic, why trusted CAs are essential, the cost factors, free options like Let’s Encrypt, and the various validation types helps developers select the appropriate certificate and configure it properly, typically via Nginx, for robust HTTPS protection.
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 guide explains why and how to migrate an HTTP site to HTTPS by obtaining free Let’s Encrypt certificates using the acme.sh script, covering installation, HTTP/DNS/standalone validation methods, certificate installation, automatic renewal, and troubleshooting steps.
After adding an HTTPS certificate to a website, browsers load fine but curl requests are reset; this article chronicles the troubleshooting steps—examining network ports, cipher suites, client buffers, SSL session cache settings, and common Nginx error logs—to pinpoint and resolve the underlying cause.
This guide walks through generating a private key, CSR, and signed certificate with OpenSSL, adding a new user and context to kubeconfig, binding the user to a cluster role, and verifying namespace‑specific permissions in a Kubernetes cluster.
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 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 generating a self‑signed SSL certificate using OpenSSL, converting it to PKCS12 and JKS formats, placing the keystore on the Jenkins server, updating Jenkins configuration for HTTPS, and testing the secure connection.
Learn how to set up a Python environment on an Ubuntu ECS, install the presto‑python‑client and PyHive libraries, configure Kerberos and SSL credentials, run sample queries against a Presto coordinator, and avoid typical errors such as NTP, SSL and authentication issues.
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.
The article analyzes a MySQL 5.7 upgrade that broke an application due to SSL being enabled by default in version 5.7.28, explains how the JDBC useSSL=true setting triggered handshake errors, and provides several practical solutions such as disabling SSL, adjusting auto‑generation settings, and updating the connection string.
When deploying a Spring Boot application on CentOS, MySQL connections may throw CommunicationsException or SSLHandshakeException due to JDK mismatches, socket path errors, SSL settings, timeout defaults, or configuration issues, and this guide explains each cause and provides concrete fixes.
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 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 comprehensive guide walks you through configuring Nginx status pages, compiling modules, using built‑in and custom variables, setting up JSON and gzip logs, enabling HTTPS, mastering rewrite rules, preventing hotlinking, implementing reverse proxy with caching, and deploying both HTTP and TCP load‑balancing with Redis and MySQL back‑ends.
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 walks through a real‑world Nginx HTTPS troubleshooting case where curl requests are reset, detailing packet captures, configuration tweaks, SSL session cache settings, and a comprehensive list of common Nginx error messages to help engineers quickly locate and resolve similar issues.
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 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 guide explains how to prepare a Spring Boot application, set up a Debian server with Java, UFW and NGINX, configure the app as a systemd service, create an NGINX reverse‑proxy, and enable HTTPS using Certbot, providing a lightweight alternative to embedded Tomcat.
This article examines how network bandwidth, protocol compression, and SSL encryption impact MySQL Group Replication performance by running sysbench benchmarks on 1 Gb and 10 Gb networks, revealing bandwidth limits, CPU overhead, and scalability issues.
This guide explains HTTPS and SSL fundamentals, shows how to generate certificates with OpenSSL, configures Nginx for secure HTTPS, details the rewrite module including break, if, return, and set directives, demonstrates read‑write separation using WebDAV, and provides anti‑hotlinking techniques with valid_referers.
This guide explains how to install Charles, configure an iPhone proxy, capture HTTP/HTTPS traffic, set breakpoints, modify requests, repeat calls, and simulate network conditions, providing a comprehensive workflow for iOS network debugging and performance testing.
This tutorial walks through setting up Nginx on Debian to serve static files, reverse‑proxy dynamic requests to Tomcat, configure load‑balancing upstreams, enable gzip compression, implement on‑disk and memory caching, and secure the server with SSL, providing full configuration examples and practical tips.
This guide explains why HTTPS is required for local web development, demonstrates how to create a self‑signed root CA and a wildcard domain certificate with OpenSSL, shows how to trust the root certificate on macOS, and provides example Webpack devServer and hosts file configurations for a secure local workflow.
This tutorial walks through Puppet's architecture, workflow, and detailed installation of a puppetmaster and puppet agents on Linux, covering SSL security, manifest creation, module development, and a practical SSH port‑remapping case study.
Learn how to obtain a free one‑year Tencent SSL certificate, download and extract the appropriate IIS files, import the certificate via IIS Manager, and bind it to your website to enable HTTPS, all with step‑by‑step screenshots.
This report evaluates how enabling SSL encryption in MySQL affects transaction‑per‑second performance, compares the OpenSSL and yaSSL libraries across SSL connection and transparent encryption test groups, and analyzes the underlying CPU, I/O, and lock bottlenecks that cause the observed performance differences.
This tutorial walks you through installing and configuring Nginx, MariaDB, PHP‑FPM, setting up a Xiaomi‑style website, securing the server with self‑signed SSL certificates, and adding basic HTTP authentication, complete with command‑line examples and configuration snippets.
This article dispels seven widespread HTTPS misconceptions—from caching and certificate costs to speed and IP requirements—explaining how browsers handle secure caching, affordable SSL options, wildcard certificates, migration steps, performance impacts, and why HTTPS is essential beyond login pages.
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 tutorial walks through setting up Nginx on Debian, configuring worker processes, events, and HTTP settings, defining upstream groups for load balancing, separating static and dynamic content with reverse proxy, enabling gzip compression, implementing proxy caching with shared memory, and adding SSL support with self‑signed certificates.
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 how to enable SSL encryption for MySQL 5.7, details the necessary configuration steps, demonstrates security testing versus unencrypted connections, and measures the resulting performance penalty, helping DBAs decide when to use SSL in production.
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 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 examines whether the ‘www’ subdomain is still necessary in 2023, discusses DNS and cookie implications, and provides practical Apache and Nginx rewrite rules for handling www‑to‑non‑www (and vice versa) redirects while considering SSL and SEO impacts.
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 tutorial walks through creating a self‑signed CA, generating keys and CSR, signing certificates, configuring nginx.conf for SSL, using the rewrite module, setting up fastcgi with PHP‑FPM, and testing the entire HTTPS setup on a Linux server.
This guide walks you through obtaining a free SSL certificate, configuring Nginx for HTTPS, and upgrading to TLS 1.2 on a CentOS server, ensuring your WeChat mini‑program can securely communicate with the backend, including detailed command‑line steps and essential software dependencies.
After Apple’s 2017 ATS enforcement requires all iOS apps to use HTTPS, developers must obtain an SSL certificate—such as a free Let’s Encrypt or Tencent Cloud‑issued GeoTrust certificate—install it on their web server (e.g., Nginx), optionally configure CDN encryption, and verify compliance with Apple’s security checks.
This guide walks through securing an Nginx web server by configuring buffer size limits, timeouts, concurrent connection controls, host and method restrictions, user‑agent blocking, hot‑link protection, directory access rules, SSL setup, PHP hardening, chroot isolation, and firewall‑level IP connection limits.
This guide walks you through obtaining a trusted SSL certificate, generating keys and CSR with OpenSSL, configuring HTTPS in Nginx, and applying performance and security enhancements such as keep‑alive, session caching, HSTS, strong cipher suites, and name‑based virtual host solutions.
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 reviews the most important MySQL 5.7 enhancements—including stronger authentication, password expiration, account locking, simplified SSL, safer initialization, updated SQL_MODE, online DDL improvements, CJK full‑text support, temporary‑table optimizations, spatial data types, and NVM‑specific tweaks—providing practical guidance and configuration examples for DBAs.
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.
This article provides a comprehensive overview of SSL/TLS, covering its architecture, differences between SSL and TLS, detailed handshake steps, key exchange processes, secret generation, security considerations, proxy handling, and references, aiming to clarify the complex concepts for readers.
This guide explains the five most common reasons an SSL certificate appears untrusted—such as using a self‑signed certificate, misconfigured trust chain, missing domain coverage, expiration, or lack of SNI support—and provides practical steps to resolve each issue.
This article provides a comprehensive overview of HTTPS, explaining its purpose, advantages, and drawbacks, and delves into the underlying cryptographic concepts such as symmetric and asymmetric encryption, hash algorithms, digital signatures, digital certificates, and the detailed SSL/TLS handshake process.
This article explains HTTPS fundamentals, its encryption mechanisms, differences from HTTP, the roles of symmetric and asymmetric cryptography, hash functions, digital signatures, certificate issuance and validation, as well as SSL/TLS protocols, handshake steps, and session resumption techniques that secure web communications.
