<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet href="/rss.xsl" type="text/xsl"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>init.d - Linux systems, DevOps and PrestaShop development</title><description>init.d - Linux sysadmins and DevOps. PrestaShop, WordPress and CMS development and support, custom software: we write the code and keep it in production.</description><link>https://initd.it</link><item><title>PHP with backported patches and NIS2: does it count as supported software?</title><link>https://initd.it/en/changelog/php-backported-patches-nis2-supported</link><guid isPermaLink="true">https://initd.it/en/changelog/php-backported-patches-nis2-supported</guid><description>Does PHP 7.4 or 8.0 with security patches backported by the Linux distribution meet ACN measure PR.PS-02 under NIS2? What the text says, what a backport really covers and what to document.</description><pubDate>Fri, 06 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;If you run websites or business applications for a client subject to NIS2, sooner or later the question arrives: &quot;are your PHP versions supported?&quot;. If the honest answer is &quot;PHP 7.4, but with the Linux distribution&apos;s security patches&quot;, the questionnaire usually has no box for that.&lt;/p&gt;
&lt;p&gt;The doubt comes from measure &lt;strong&gt;PR.PS-02&lt;/strong&gt; of the Italian cybersecurity agency ACN&apos;s basic specifications: only software with guaranteed availability of security updates may be installed, and updates must be applied without undue delay. PHP 7.4 and 8.0 have been end of life for the PHP project since November 2022 and November 2023, yet some Linux distributions (Red Hat and its derivatives for both, Ubuntu with a Pro subscription for 7.4) keep fixing their flaws through &lt;strong&gt;backporting&lt;/strong&gt;: they take the fix written for the recent version and apply it to the old code, leaving the version number unchanged. Is anyone in that situation inside or outside the measure?&lt;/p&gt;
&lt;p&gt;An honest premise, as in &lt;a href=&quot;/en/changelog/nis2-suppliers-what-to-prepare&quot;&gt;NIS2 and suppliers&lt;/a&gt;: this is not legal advice but a technical reading of the measure&apos;s text, ACN&apos;s FAQ and the policies of Red Hat, Debian and Ubuntu; it follows the Italian rules, because that is where most of our clients are, and where ACN has not spoken we say so.&lt;/p&gt;
&lt;h2&gt;What PR.PS-02 actually says (and what it doesn&apos;t)&lt;/h2&gt;
&lt;p&gt;The text in Annex 1 of ACN Determination 379907 of 19 December 2025 is in Italian; the translations below are ours and the quoted fragments are the original. Point 1: without prejudice to motivated and documented regulatory or technical reasons, and in accordance with the results of the risk assessment under measure ID.RA-05, only software, operating systems included, &quot;per il quale è garantita la disponibilità di aggiornamenti di sicurezza&quot; (for which the availability of security updates is guaranteed) is installed. Point 2, with the same opening clause on documented reasons: the latest security updates &quot;rilasciati dal produttore&quot; (released by the producer) are installed &quot;senza ingiustificato ritardo&quot; (without undue delay).&lt;/p&gt;
&lt;p&gt;Two details matter. Point 1 is written in the passive voice: it does not say who has to guarantee the updates. The word &quot;produttore&quot; appears only in point 2 and ACN&apos;s NIS FAQ never defines it; none of those FAQ deals with backporting or with software end of life (checked on 6 November 2026). So saying that a PHP with the Linux distributor&apos;s patches meets the measure is this article&apos;s authors&apos; interpretation, a reasonable one, but not an ACN position.&lt;/p&gt;
&lt;p&gt;The second detail is that the measure provides for exceptions by itself. The clause on the results of the risk assessment (&quot;in accordo agli esiti della valutazione del rischio&quot;) was added precisely with the December 2025 update (FAQ DSB.1), and measure ID.RA-08 asks to resolve vulnerabilities through security updates or mitigation measures, where available, or else by accepting and documenting the risk in the risk treatment plan. In plain terms: software outside the rule is not banned outright, but it must be justified, assessed and documented. In contracts, the client transposes the substance of the measure rather than its wording (FAQ MSB.16): the phrasing you will find in the questionnaire is the client&apos;s choice.&lt;/p&gt;
&lt;h2&gt;Backporting: what it really covers and what it doesn&apos;t&lt;/h2&gt;
&lt;p&gt;Red Hat states that &quot;for most products, our default practice is to backport security fixes&quot;, and warns customers that &quot;just looking at the version number of a package will not tell them if they are vulnerable or not&quot;: what counts is the security advisory with its CVE code, the public identifier of each flaw. Debian&apos;s Security FAQ gives the same guidance: check the package changelog, or compare the exact version number with the one in the advisory. How to verify that on the server is something we showed with &lt;a href=&quot;/en/changelog/php2shell-critical-php-vulnerabilities&quot;&gt;PHP2Shell&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;The limits deserve the same clarity.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;It only covers the flaws the distributor decides to fix, on its own scale.&lt;/strong&gt; RHEL 8 is in its maintenance phase, where Red Hat&apos;s standard errata criteria cover Critical and Important CVEs and Moderate ones with a CVSS score (the 0 to 10 scale that measures how severe a flaw is) of 7 or higher, and &quot;all errata are provided at Red Hat&apos;s discretion&quot;. Ubuntu Pro promises fixes for &quot;critical, high and selected medium&quot; vulnerabilities. Debian LTS (the &lt;em&gt;Long Term Support&lt;/em&gt; run by a group of volunteers and companies) warns that &quot;not all packages of the Debian archive are supported by LTS&quot;. The scale belongs to the distributor: PHP2Shell scores 9.2 out of 10 on the CVSS 4.0 scale used by the PHP project, &quot;Important&quot; at 8.1 on Red Hat&apos;s CVSS 3.1 scale, while the US NVD gives 9.8 on that same 3.1 scale.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;No new features, no fixes that are not security fixes.&lt;/strong&gt; And the ecosystem does not read changelogs, the package&apos;s record of changes: WordPress, PrestaShop and Composer libraries look at the version number, as we explain in &lt;a href=&quot;/en/changelog/php-end-of-life-risks&quot;&gt;PHP end of life&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;A backport has an expiry date, the distribution&apos;s.&lt;/strong&gt; Not php.net&apos;s, which for 8.2 is 31 December 2026, for 8.3 31 December 2027, for 8.4 31 December 2028 and for 8.5 31 December 2029.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Running servers on PHP 7.4 or 8.0, with a client asking whether they are supported?&quot; text=&quot;We inventory versions, patch sources and end-of-support dates across your Linux servers and tell you what is defensible, what to migrate first and what to write in the questionnaire.&quot; button=&quot;Ask for the inventory →&quot;}&lt;/p&gt;
&lt;h2&gt;The concrete case: the same PHP 7.4 on Rocky or AlmaLinux 8, three different sources&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;From the distribution&apos;s module.&lt;/strong&gt; In RHEL 8 the &lt;code&gt;php:7.4&lt;/code&gt; &lt;strong&gt;stream&lt;/strong&gt; (the versioned package set the distribution publishes and maintains) is a &quot;Full Life&quot; stream: it follows the operating system&apos;s life cycle, with the maintenance phase running until 31 May 2029; AlmaLinux 8 and Rocky Linux 8 end security support on the same day. The proof: on 21 October 2026 Red Hat published advisory RHSA-2026:87080 for &lt;code&gt;php:7.4&lt;/code&gt; with both PHP2Shell flaws, and on 22 October ALSA-2026:87080 and RLSA-2026:87080 followed for AlmaLinux and Rocky. The instructive comparison is on RHEL 9: PHP 8.0, a &quot;Full Life&quot; stream, received the fix (RHSA-2026:87151); PHP 8.1, a stream retired in May 2025, does not appear in the list of advisories on Red Hat&apos;s CVE page (checked on 6 November 2026). The stream decides, not the PHP number.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;From the Remi repository.&lt;/strong&gt; The same PHP 7.4, but from a third-party repository maintained by one person. In his end-of-life announcement for 7.4, Remi writes that &quot;this is a best effort action, depending on my spare time, without any warranty, only to give users more time to migrate&quot;. For PHP2Shell the repository&apos;s 7.4, 8.0 and 8.1 packages carry the date of 21 October in their changelog, the same day as the release, under the entry &quot;Mitigation fix&quot;: it is the minimal source backport the PHP project provided for the closed branches. Valuable work, but with no contract nor end-of-support date to write into a document. The same goes for Ondřej Surý&apos;s repository for Debian and Ubuntu, which he says he maintains &quot;mostly in my free time&quot;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Debian and Ubuntu.&lt;/strong&gt; On Ubuntu 20.04 PHP 7.4 was fixed with package &lt;code&gt;7.4.3-4ubuntu2.29+esm5&lt;/code&gt;, but only through Ubuntu Pro (free for personal use on up to 5 physical machines), covered until May 2030. Debian 12 ships PHP 8.2, which php.net closes on 31 December 2026; Debian 12 is in LTS until 30 June 2028 and October&apos;s fix came from the LTS team with advisory DLA-4848-1 of 21 October. Debian 11 with PHP 7.4, on the other hand, left LTS on 31 August 2026: what remains is Freexian&apos;s Extended LTS (ELTS), a commercial service that the Debian wiki says &quot;is not an official Debian project&quot;, whose package scope &quot;is defined by the organizations which subscribe&quot;; for php7.4 it published advisory ELA-1853-1 on 21 October, citing both PHP2Shell CVEs.&lt;/p&gt;
&lt;h2&gt;What you can defend in front of a client, and what you can&apos;t&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Defensible&lt;/strong&gt;: patches from the distributor, with a public life cycle, advisories carrying CVE codes and a definite end date. In a questionnaire you write: &quot;PHP 7.4 from the &lt;code&gt;php:7.4&lt;/code&gt; module of AlmaLinux 8, supported by the distributor until 31 May 2029, latest advisory ALSA-2026:87080 of 22 October 2026, migration to PHP 8.3 planned by ...&quot;. It remains an interpretation: a client whose contract says &quot;version supported by the software producer&quot; may not accept it.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Defensible only as a temporary exception&lt;/strong&gt;: third-party repositories. This is the measure&apos;s &quot;documented technical reason&quot;, with a risk assessment, a migration date and compensating measures. It is not a stable state to settle into.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Not defensible&lt;/strong&gt;: PHP 7.3 or earlier, Debian 11 without ELTS, a hosting provider that &quot;says&quot; it patched without an advisory to show, or &quot;php -v shows 7.4.33, so it&apos;s up to date&quot;. If the server handles personal data, the &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR on the infrastructure side&lt;/a&gt; adds to the NIS2 picture, and an abandoned component is hard to sustain as &quot;state of the art&quot;.&lt;/p&gt;
&lt;h2&gt;What to document: the sheet to show the client&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Inventory&lt;/strong&gt;: server, exact package version (for example &lt;code&gt;php-common-7.4.33-8.module_el8.10.0+4321+cf5fd4bb.x86_64&lt;/code&gt;, what &lt;code&gt;rpm -q php-common&lt;/code&gt; returns on AlmaLinux 8 on 6 November 2026), execution mode (PHP-FPM or mod_php) and applications served.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Patch source&lt;/strong&gt;: distribution stream or third-party repository, with a link to the life cycle policy.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Two end-of-support dates&lt;/strong&gt;: the distributor&apos;s and php.net&apos;s, written side by side.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Proof of the latest patch&lt;/strong&gt;: advisory id and date, plus the changelog line that cites the CVE. On Debian and Ubuntu the package name follows the distribution&apos;s PHP version (&lt;code&gt;php8.2-common&lt;/code&gt; on Debian 12, &lt;code&gt;php8.4-common&lt;/code&gt; on Debian 13, &lt;code&gt;php8.3-common&lt;/code&gt; on Ubuntu 24.04, &lt;code&gt;php7.4-common&lt;/code&gt; on Ubuntu 20.04):&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;zcat /usr/share/doc/php8.2-common/changelog.Debian.gz | grep -m1 &apos;CVE-2026-10961[89]&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;On AlmaLinux, Rocky and RHEL:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;rpm -q --changelog php-common | grep -m1 &apos;CVE-2026-10961[89]&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;We re-ran both commands on 6 November 2026 in clean containers: on Debian 12 (&lt;code&gt;8.2.35-1~deb12u1&lt;/code&gt;), Debian 13 (&lt;code&gt;8.4.27-1~deb13u1&lt;/code&gt;), Ubuntu 24.04 (&lt;code&gt;8.3.6-0ubuntu0.24.04.13&lt;/code&gt;) and AlmaLinux 8 with the &lt;code&gt;php:7.4&lt;/code&gt; module the line with the two CVEs comes out. On Ubuntu 20.04 without Ubuntu Pro the package stops at &lt;code&gt;7.4.3-4ubuntu2.29&lt;/code&gt; and the command prints nothing: an empty result is the proof that the fix is not there.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Migration plan&lt;/strong&gt;: target version, date, owner, staging environment and rollback plan.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Compensating measures&lt;/strong&gt;: a &lt;a href=&quot;/en/changelog/nginx-reverse-proxy&quot;&gt;reverse proxy&lt;/a&gt; or WAF (the filter that inspects requests before they reach the site) with request limits, network segmentation, multi-factor authentication on administrative access, centralised logs.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Formal exception&lt;/strong&gt;: the technical reason (for example a custom application not compatible with PHP 8), the risk assessment and the acceptance in the treatment plan, signed by whoever decides.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;If the missing step is the migration, moving a site to a supported PHP version is a &lt;a href=&quot;/en/fixes/wordpress-update&quot;&gt;fix&lt;/a&gt; from €149, with the price set in the quote and a test on a copy before production is touched; for e-commerce stores and custom code we quote after the inventory.&lt;/p&gt;
&lt;h2&gt;In summary&lt;/h2&gt;
&lt;p&gt;PR.PS-02 asks for software with guaranteed security updates, does not say from whom, and provides for justified, documented exceptions. A PHP that is end of life for php.net but covered by the distribution&apos;s module, with public advisories and a definite end date, is a defensible position, provided you understand that a backport only covers the flaws the distributor chooses to fix and expires with the distribution. The same PHP from a third-party repository is a bridge, to be documented as an exception with an arrival date. Everything else does not hold up in front of a questionnaire, nor in front of a scanner.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Need to answer a NIS2 questionnaire about servers running end-of-life PHP?&quot; text=&quot;We prepare the technical sheet for your client: inventory, patch sources, end-of-support dates, compensating measures and migration plan, then we migrate the sites to a supported version. We manage Linux servers and PHP applications for SMEs, firms and agencies.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.acn.gov.it/portale/documents/d/guest/allegato-1-v2&quot;&gt;ACN, Annex 1: basic security measures for important entities (PR.PS-02, ID.RA-05, ID.RA-08, in Italian)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.acn.gov.it/portale/en/faq/nis/misure-di-sicurezza-e-notifica-di-incidenti&quot;&gt;ACN, NIS FAQ: security measures and incident notification (DSB.1, MSB.16, in Italian)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.acn.gov.it/portale/en/nis/modalita-specifiche-base&quot;&gt;ACN, Basic obligations and specifications (Determination 379907/2025)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/supported-versions.php&quot;&gt;PHP, Supported Versions&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/eol.php&quot;&gt;PHP, Unsupported Branches&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/archive/2026.php#2026-10-21-5&quot;&gt;PHP, security advisory of 21 October 2026 (minimal source backports for 7.4, 8.0 and 8.1)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w&quot;&gt;GitHub, advisory GHSA-w8hw-w9fx-j79w for CVE-2026-109618 (CVSS 4.0)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://nvd.nist.gov/vuln/detail/CVE-2026-109618&quot;&gt;NVD, CVE-2026-109618&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://access.redhat.com/security/updates/backporting&quot;&gt;Red Hat, Backporting security fixes&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://access.redhat.com/support/policy/updates/errata&quot;&gt;Red Hat, Enterprise Linux Life Cycle (errata criteria in the maintenance phase)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://access.redhat.com/support/policy/updates/rhel-app-streams-life-cycle&quot;&gt;Red Hat, Application Streams Life Cycle (PHP streams)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://access.redhat.com/security/cve/CVE-2026-109618&quot;&gt;Red Hat, CVE-2026-109618&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://errata.almalinux.org/8/ALSA-2026-87080.html&quot;&gt;AlmaLinux, ALSA-2026:87080 php:7.4 security update&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://wiki.almalinux.org/release-notes/#almalinux-os-8&quot;&gt;AlmaLinux, Release Notes (AlmaLinux 8 security support until 31 May 2029)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://errata.rockylinux.org/RLSA-2026:87080&quot;&gt;Rocky Linux, RLSA-2026:87080&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://rockylinux.org/download&quot;&gt;Rocky Linux, Download (planned EOL of Rocky Linux 8)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.remirepo.net/post/2022/11/29/PHP-7.4-is-retired&quot;&gt;Remi, &quot;PHP 7.4 is retired&quot;&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://rpms.remirepo.net/enterprise/8/modular/x86_64/&quot;&gt;Remi, modular repository for Enterprise Linux 8 (changelog of packages php-common 7.4.33-31, 8.0.30-21 and 8.1.34-6)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.debian.org/security/faq&quot;&gt;Debian, Security FAQ&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://wiki.debian.org/LTS&quot;&gt;Debian, LTS: schedule&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://wiki.debian.org/LTS/Using&quot;&gt;Debian, LTS: unsupported packages&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://lists.debian.org/debian-lts-announce/2026/10/msg00042.html&quot;&gt;Debian, DLA-4848-1 php8.2 security update&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://wiki.debian.org/LTS/Extended&quot;&gt;Debian, Extended LTS (Freexian)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.freexian.com/lts/extended/updates/ela-1853-1-php7.4/&quot;&gt;Freexian, ELA-1853-1 php7.4 security update&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://ubuntu.com/security/esm&quot;&gt;Ubuntu, Expanded Security Maintenance&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://ubuntu.com/pro&quot;&gt;Ubuntu Pro (free for personal use)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://ubuntu.com/security/CVE-2026-109618&quot;&gt;Ubuntu, CVE-2026-109618&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://deb.sury.org/&quot;&gt;deb.sury.org, PHP packages for Debian and Ubuntu&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>CVE-2026-98432: the Linux kernel TCP flaw, who is at risk and how to close it</title><link>https://initd.it/en/changelog/cve-2026-98432-linux-kernel-tcp-what-to-do</link><guid isPermaLink="true">https://initd.it/en/changelog/cve-2026-98432-linux-kernel-tcp-what-to-do</guid><description>CVE-2026-98432, use-after-free in the Linux kernel&apos;s IPv4 TCP code: affected kernels, patches for Debian, Ubuntu, RHEL, AlmaLinux, Rocky and CloudLinux on 6 November 2026, how to verify and update.</description><pubDate>Fri, 06 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;On 15 October 2026 the Linux kernel CVE team published &lt;strong&gt;CVE-2026-98432&lt;/strong&gt;, a flaw in the code that accepts incoming TCP connections over IPv4, and the CNA&apos;s entry gives it a score of &lt;strong&gt;9.8 out of 10&lt;/strong&gt;. On 27 October Anthropic stated that one of its research models had written an exploit that, by sending packets to a Linux server with an MPTCP listener, runs commands as root with no credentials. Hence the headlines claiming that every Linux server with an open port is at risk. That is only partly true, and the true part is enough to act on.&lt;/p&gt;
&lt;p&gt;The faulty code lives in the &lt;strong&gt;kernel&lt;/strong&gt;, the core of the operating system, and has been there since kernel 4.4, released in January 2016: it concerns almost every Linux server in production, whatever software runs on top. Below: what goes wrong, who is exposed and under which conditions, the patch status verified on 6 November 2026 at 12:12 UTC, how to verify and update, and in short the firewall stopgap for those who cannot reboot right away, which has an article of its own. Where sources disagree, we say so.&lt;/p&gt;
&lt;h2&gt;What goes wrong in the kernel, in plain words and then in detail&lt;/h2&gt;
&lt;p&gt;Every TCP connection starts with a handshake: the client sends a SYN packet (&quot;I would like to connect&quot;), the server replies with a SYN-ACK, the client confirms. Meanwhile the server keeps a note about the request. If the SYN carries &lt;strong&gt;IP options&lt;/strong&gt;, an optional field of the IPv4 header designed decades ago for network diagnostics (for example &quot;record the route&quot;), the server stores them in that note to reuse them in the reply.&lt;/p&gt;
&lt;p&gt;The mistake is in the handover: when the connection completes, the kernel moves the options from the note to the real connection without making a copy. If at that very moment a retransmitted SYN arrives and another processor is handling it, that processor reads the options the first one has already thrown away. That is a &lt;strong&gt;use-after-free&lt;/strong&gt;, using memory after releasing it: like a clerk reading a sheet of paper while a colleague has already shredded it and the paper has been reassigned to another file. He reads data that no longer belongs there and, in some cases, writes on it.&lt;/p&gt;
&lt;p&gt;The technical detail, from Eric Dumazet&apos;s fix commit: &lt;code&gt;tcp_v4_syn_recv_sock()&lt;/code&gt; transfers &lt;code&gt;ireq-&amp;gt;ireq_opt&lt;/code&gt; to the child socket without duplicating it; a retransmitted SYN processed concurrently builds the SYN-ACK reading those options under &lt;code&gt;rcu_read_lock()&lt;/code&gt; only, while &lt;code&gt;inet_sock_destruct()&lt;/code&gt; frees them with a plain &lt;code&gt;kfree()&lt;/code&gt;, and &lt;code&gt;ip_options_build()&lt;/code&gt; reads freed memory. A similar variant, in &lt;code&gt;tcp_v4_reqsk_destructor()&lt;/code&gt;, concerns request migration between listening sockets, active only with &lt;code&gt;net.ipv4.tcp_migrate_req=1&lt;/code&gt; or a BPF program. The fix is two lines: &lt;code&gt;kfree()&lt;/code&gt; becomes &lt;code&gt;kfree_rcu()&lt;/code&gt; in &lt;code&gt;net/ipv4/af_inet.c&lt;/code&gt; and &lt;code&gt;net/ipv4/tcp_ipv4.c&lt;/code&gt;, so the memory is released only once every reader is done. The defect dates back to commit &lt;code&gt;079096f103fa&lt;/code&gt;, from October 2015, which shipped in Linux 4.4. IPv6 is not affected by the first issue; for the migration variant alone the commit announces a separate fix.&lt;/p&gt;
&lt;p&gt;What an attacker can achieve, in order of difficulty: crash the machine (&lt;em&gt;denial of service&lt;/em&gt;), read fragments of kernel memory, corrupt it (that is Red Hat&apos;s assessment) and, in the case described by Anthropic, run commands as root: 48 minutes to leak a kernel pointer, the step that defeats kernel address randomisation (KASLR), and another five to reach command execution. The CVE record justifies the low attack complexity with the fact that the attacker can create option-bearing requests and repeat the race between processors as many times as needed.&lt;/p&gt;
&lt;h2&gt;Who is at risk: affected kernels and distribution status on 6 November 2026&lt;/h2&gt;
&lt;p&gt;According to the CVE record, every kernel from 4.4 onwards without the fix is vulnerable; the fixed stable branches are &lt;strong&gt;5.10.272, 5.15.223, 6.1.190, 6.6.159, 6.12.113, 6.18.56, 7.2.10&lt;/strong&gt; and the upcoming 7.3. Distributions carry the fix onto their own version: the advisory is what counts, not the number, as with the &lt;a href=&quot;/en/changelog/php-backported-patches-nis2-supported&quot;&gt;distributor&apos;s backported patches&lt;/a&gt;.&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Distribution&lt;/th&gt;
&lt;th&gt;Fixed kernel (or later)&lt;/th&gt;
&lt;th&gt;Advisory and date&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Debian 13 &quot;trixie&quot;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;linux&lt;/code&gt; 6.12.113-1&lt;/td&gt;
&lt;td&gt;DSA-6568-1, 16 October&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Debian 12 &quot;bookworm&quot;&lt;/td&gt;
&lt;td&gt;&lt;code&gt;linux&lt;/code&gt; 6.1.190-1; &lt;code&gt;linux-6.12&lt;/code&gt; 6.12.113-1~deb12u1&lt;/td&gt;
&lt;td&gt;DLA-4841-1 and DLA-4850-1 (LTS)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ubuntu 24.04 LTS&lt;/td&gt;
&lt;td&gt;&lt;code&gt;linux&lt;/code&gt; 6.8.0-149.149&lt;/td&gt;
&lt;td&gt;in &lt;code&gt;noble-updates&lt;/code&gt; since 6 November, 01:14 UTC; no USN at the time of checking&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ubuntu 22.04 LTS&lt;/td&gt;
&lt;td&gt;&lt;code&gt;linux&lt;/code&gt; 5.15.0-203.213&lt;/td&gt;
&lt;td&gt;in &lt;code&gt;jammy-updates&lt;/code&gt; since 5 November, 23:22 UTC; no USN at the time of checking&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ubuntu 26.04 LTS&lt;/td&gt;
&lt;td&gt;&lt;code&gt;linux&lt;/code&gt; 7.0.0-43.43&lt;/td&gt;
&lt;td&gt;in &lt;code&gt;resolute-updates&lt;/code&gt; since 6 November, 01:14 UTC; no USN at the time of checking&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ubuntu 20.04 LTS&lt;/td&gt;
&lt;td&gt;none&lt;/td&gt;
&lt;td&gt;fix pending according to Canonical; HWE kernel 5.15.0-203.213~20.04.1 work in progress&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RHEL 8.10&lt;/td&gt;
&lt;td&gt;&lt;code&gt;kernel&lt;/code&gt; 4.18.0-553.182.1.el8_10&lt;/td&gt;
&lt;td&gt;RHSA-2026:93414, 1 November&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RHEL 9.8&lt;/td&gt;
&lt;td&gt;&lt;code&gt;kernel&lt;/code&gt; 5.14.0-687.64.1.el9_8&lt;/td&gt;
&lt;td&gt;RHSA-2026:93412, 1 November&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RHEL 10.2&lt;/td&gt;
&lt;td&gt;&lt;code&gt;kernel&lt;/code&gt; 6.12.0-211.72.1.el10_2&lt;/td&gt;
&lt;td&gt;RHSA-2026:93413, 1 November&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AlmaLinux 8, 9, 10&lt;/td&gt;
&lt;td&gt;same versions as RHEL&lt;/td&gt;
&lt;td&gt;production repositories since 2 November&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rocky Linux 8, 9, 10&lt;/td&gt;
&lt;td&gt;same versions as RHEL&lt;/td&gt;
&lt;td&gt;RLSA-2026:93414, 93412 and 93413, 3 November&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CloudLinux 7h and 8&lt;/td&gt;
&lt;td&gt;4.18.0-553.180.1.lve.1&lt;/td&gt;
&lt;td&gt;since 30 October; CL9 (5.14.0-687.64.1.el9_8) and CL10 (6.12.0-211.73.1.el10_2) in the stable channel since 3 November&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Oracle Linux 8, 9, 10&lt;/td&gt;
&lt;td&gt;see Oracle&apos;s CVE page&lt;/td&gt;
&lt;td&gt;ELSA-2026-93414, 93412 and 93413, 2 November; UEK kernels since 16 October&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Amazon Linux 2 and 2023&lt;/td&gt;
&lt;td&gt;see Amazon&apos;s CVE page&lt;/td&gt;
&lt;td&gt;ALAS advisories from 24 to 30 October&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SUSE SLES 15 SP4-SP7 and 16.0&lt;/td&gt;
&lt;td&gt;see SUSE&apos;s CVE page&lt;/td&gt;
&lt;td&gt;SUSE-SU advisories from 29 October to 5 November&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;Notes. On Ubuntu the picture changed in the last few hours: Canonical&apos;s blog post of 2 November talked about &lt;code&gt;-proposed&lt;/code&gt; and the CVE page updated on the 5th still marks the three versions as work in progress, but the Launchpad API shows them published to &lt;code&gt;-updates&lt;/code&gt; between 23:22 UTC on 5 November and 01:14 on 6 November, in an Ubuntu 24.04 container &lt;code&gt;apt-cache policy&lt;/code&gt; offers 6.8.0-149.149 from &lt;code&gt;noble-updates&lt;/code&gt; and that kernel&apos;s changelog contains the fix commit. At the time of checking there is no USN and &lt;code&gt;-security&lt;/code&gt; still holds the previous kernel: the default &lt;code&gt;unattended-upgrades&lt;/code&gt; configuration on Ubuntu (&lt;code&gt;/etc/apt/apt.conf.d/50unattended-upgrades&lt;/code&gt;, read on 24.04) does not include &lt;code&gt;-updates&lt;/code&gt;, so anyone relying on automatic updates does not get this kernel until the USN is out and has to install it by hand. For the HWE kernels (6.8 on 22.04, 5.15 on 20.04) Launchpad still shows the previous versions in &lt;code&gt;-updates&lt;/code&gt; (6.8.0-149.149~22.04.1 has been in &lt;code&gt;jammy-proposed&lt;/code&gt; since 29 October) and the CVE page marks the fixed ones as work in progress. RHEL minor releases under extended support have their own advisories on Red Hat&apos;s CVE page. Debian 11 has been out of LTS since 31 August 2026 and does not appear in Debian&apos;s tracker: we do not know its status. RHEL 7 (Red Hat marks it as not affected) and CloudLinux 7 (not affected according to CloudLinux) do not need the fix.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Running exposed Linux servers without knowing which kernel is really running?&quot; text=&quot;We inventory the machines, compare the running kernel with the distribution&apos;s advisory, apply the firewall stopgap where a reboot cannot wait and schedule the update and reboot out of hours.&quot; button=&quot;Ask for the check →&quot;}&lt;/p&gt;
&lt;h2&gt;Is an open TCP port enough? The real conditions&lt;/h2&gt;
&lt;p&gt;Two versions circulate on blogs, &quot;it needs MPTCP&quot; and &quot;any TCP port will do&quot;. The primary sources settle it.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Any service listening on IPv4 TCP is a target.&lt;/strong&gt; The commit never mentions MPTCP; Red Hat&apos;s bulletin states that RHEL systems with MPTCP disabled, as it is by default, remain affected; AlmaLinux writes that &quot;The bug itself is in the regular IPv4 TCP code, so systems without MPTCP still need the fix&quot;, and the Go security team writes that &quot;It is possible that systems with no MPTCP listeners are vulnerable to similar attacks&quot;. Anthropic&apos;s exploit uses an &lt;strong&gt;MPTCP&lt;/strong&gt; listener (&lt;em&gt;Multipath TCP&lt;/em&gt;, the extension that lets one connection travel over several paths): it is the demonstrated route to code execution, not the only route to the defect. On a plain TCP listener we know of no public demonstration of code execution; Red Hat justifies the Critical rating with memory corruption and crashes reachable over ordinary IPv4 TCP traffic.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The SYN must carry IPv4 options.&lt;/strong&gt; Without options the structure that gets freed too early does not exist: every distributor&apos;s mitigation relies on this.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;IPv4 only.&lt;/strong&gt; A service reachable only over IPv6 is not involved.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The &quot;migration&quot; variant is off by default:&lt;/strong&gt; &lt;code&gt;net.ipv4.tcp_migrate_req&lt;/code&gt; is 0 unless you changed it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Internal networks included.&lt;/strong&gt; Anyone who can send a SYN to the service can try: an infected laptop on the LAN is as good as the internet.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Containers and virtual machines.&lt;/strong&gt; A container uses the host&apos;s kernel: a port published by Docker on a vulnerable host is vulnerable, whatever runs inside. A VM depends on its own kernel, not the hypervisor&apos;s.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Routers, NAT and network firewalls.&lt;/strong&gt; RFC 7126 speaks of a &quot;widespread practice of blocking IPv4 optioned packets&quot;, but widespread does not mean guaranteed: you do not know what your provider does, and a Linux router doing NAT has listening services of its own. Who actually uses IP options, and how rare they are, is in the article on the stopgap.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Cloud security groups.&lt;/strong&gt; An AWS security group rule specifies protocol, ports, ICMP type and source: there is no field for IP options, so it does not replace the filter described below.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;What we know and what we don&apos;t&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Certain (primary sources)&lt;/th&gt;
&lt;th&gt;Stated limits&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Fix by Eric Dumazet on a report by Xinyang Ge (anthropic.com address in the commit), written on 1 October and applied on the 5th, available in Linux 7.3-rc7&lt;/td&gt;
&lt;td&gt;Anthropic did not publish code, kernel version or exploit configuration with its article; we know of no independent reproduction&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CVSS 9.8 from the kernel CVE team and Red Hat (Critical); 8.1 from SUSE and Amazon (Important) and from Oracle (preliminary)&lt;/td&gt;
&lt;td&gt;Which of the two numbers describes the risk better depends on how hard the race between processors is to win, and Red Hat itself writes that reliable code execution requires precise control of memory&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Anthropic claims a root exploit against a server with an MPTCP listener&lt;/td&gt;
&lt;td&gt;Exploitation in the wild: none of the primary sources we read reports it&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Not in the CISA KEV catalog (version 2026.11.04, checked on 6 November at 12:12 UTC)&lt;/td&gt;
&lt;td&gt;The catalog only records confirmed exploitation: absence is not a guarantee&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;The firewall rule looks only at IP options: in our tests HTTP traffic, even inside a WireGuard tunnel, never touches it, and the kernel already drops source routing&lt;/td&gt;
&lt;td&gt;How many packets with IP options actually reach a production server: the last measurement we know of is from 2005, and we made none on your server&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;On the numbers: 9.8 and 8.1 differ by a single entry of the CVSS vector, attack complexity: &lt;code&gt;AC:L&lt;/code&gt; for the kernel team and Red Hat, &lt;code&gt;AC:H&lt;/code&gt; for SUSE, Oracle and Amazon. Red Hat justifies the Critical rating with the absence of prerequisites beyond IPv4 TCP traffic and the risk of severe instability, while conceding that reliable code execution requires precise control of memory.&lt;/p&gt;
&lt;h2&gt;If you cannot update right away: the firewall stopgap in short&lt;/h2&gt;
&lt;p&gt;Red Hat in its bulletin and AlmaLinux on its blog publish the same idea: drop IPv4 TCP packets with IP options, that is with a header longer than 20 bytes (&lt;code&gt;ip hdrlength &amp;gt; 5&lt;/code&gt;, in 32-bit words). Neither presents it as a fix: Red Hat speaks of reducing exposure, AlmaLinux writes &quot;Neither step is a fix&quot;, and the Ubuntu Security Team that &quot;security updates are the only appropriate mitigation&quot;. AlmaLinux&apos;s variant hooks the &lt;code&gt;prerouting&lt;/code&gt; point, so it also covers ports published by Docker, which are diverted in the &lt;code&gt;nat&lt;/code&gt; table before they reach &lt;code&gt;input&lt;/code&gt;; in exchange it also drops forwarded traffic, if the machine acts as a router. In the file &lt;code&gt;/etc/cve-2026-98432.nft&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;table ip cve_2026_98432 {
	chain prerouting {
		type filter hook prerouting priority -300; policy accept;
		meta l4proto tcp ip hdrlength &amp;gt; 5 counter drop
	}
}
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;sudo nft -c -f /etc/cve-2026-98432.nft
sudo nft -f /etc/cve-2026-98432.nft
sudo nft list table ip cve_2026_98432
sudo nft delete table ip cve_2026_98432
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The four commands check, load, show and remove the rule; the &lt;code&gt;counter&lt;/code&gt; tells you how many packets it dropped. We tested them in a Debian 13 container and on a Docker host with a published port: HTTP traffic never touches the counter, a SYN with the &quot;record route&quot; option is counted and, with &lt;code&gt;drop&lt;/code&gt;, dropped. The table does not survive a reboot and, in our test on a Docker host, does not see traffic between two containers on the same bridge: AlmaLinux warns that such traffic may bypass it. The iptables and ufw variants, persistence, what it can break, how to introduce it in observation mode first and the other mitigations (MPTCP off, livepatch, &lt;code&gt;init_on_free&lt;/code&gt;) are in &lt;a href=&quot;/en/changelog/cve-2026-98432-firewall-workaround-nftables&quot;&gt;the article on the firewall stopgap&lt;/a&gt;: here it is enough to say that it is a bridge to the maintenance window, not a way to skip it.&lt;/p&gt;
&lt;h2&gt;How to check whether you are vulnerable and how to update&lt;/h2&gt;
&lt;p&gt;The running kernel is shown by &lt;code&gt;uname -r&lt;/code&gt;; the real check is the package changelog, because distributions do not change the upstream version number, as with &lt;a href=&quot;/en/changelog/php2shell-critical-php-vulnerabilities&quot;&gt;PHP2Shell&lt;/a&gt;. Before touching production, &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;a verified backup&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;On Debian the kernel changelog is &lt;code&gt;changelog.gz&lt;/code&gt; in the package&apos;s documentation folder (verified on Debian 13 with package 6.12.115-2, where the line sits in the 6.12.113-1 block):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;uname -r
sudo apt update &amp;amp;&amp;amp; sudo apt install linux-image-amd64
zcat /usr/share/doc/linux-image-$(uname -r)/changelog.gz | grep -m1 CVE-2026-98432
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;On Ubuntu the changelog lists the fix by the commit title, on 24.04 in the &quot;Noble update: upstream stable patchset 2026-10-21&quot; block, not by CVE number: searching for &lt;code&gt;CVE-2026-98432&lt;/code&gt; finds nothing. First check that the repository offers the fixed version:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;apt-cache policy linux-image-generic
sudo apt update &amp;amp;&amp;amp; sudo apt install linux-generic
apt-get changelog linux-modules-$(uname -r) | grep -m1 &apos;inet_opt and ireq_opt&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;On AlmaLinux 9 the package changelog cites the CVE (verified with &lt;code&gt;kernel-core&lt;/code&gt; 5.14.0-687.66.1.el9_8; we did not check RHEL and Rocky), and the line reads &quot;ipv4: free inet_opt and ireq_opt after an RCU grace period (CKI Backport Bot) [RHEL-295635] {CVE-2026-98432}&quot;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sudo dnf clean metadata &amp;amp;&amp;amp; sudo dnf upgrade kernel
rpm -q --changelog kernel-core-$(uname -r) | grep -m1 CVE-2026-98432
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Then reboot: the new kernel is not active until the machine restarts, and &lt;code&gt;uname -r&lt;/code&gt; after the reboot must show the fixed version (&lt;code&gt;dnf needs-restarting -r&lt;/code&gt;, from the dnf-plugins-core package, and Ubuntu&apos;s &lt;code&gt;/var/run/reboot-required&lt;/code&gt; file tell you whether it is needed: both tried in the containers). On Ubuntu 20.04 the fix is pending: standard support ended in May 2025 and security updates arrive through Ubuntu Pro (ESM), free for personal use on up to five physical machines. It is also the moment to count your exposed ports: every reachable service is a target, and going through &lt;a href=&quot;/en/changelog/bastion-host&quot;&gt;a bastion host&lt;/a&gt; or a VPN takes quite a few off the list. If you would rather have someone else do it, the &lt;a href=&quot;/en/services/security&quot;&gt;server security check&lt;/a&gt; covers exactly exposed ports, firewall and missing updates, on quote once we have seen the scope.&lt;/p&gt;
&lt;h2&gt;In summary&lt;/h2&gt;
&lt;p&gt;CVE-2026-98432 is a use-after-free in the Linux kernel&apos;s handling of IPv4 TCP connections, present since 2016 and fixed with two lines. It affects any service listening on IPv4 that receives a SYN with IP options, not just MPTCP, which is the route Anthropic demonstrated to reach root. As of 6 November, fixes exist for Debian, RHEL 8, 9 and 10 with AlmaLinux, Rocky and CloudLinux, SUSE, Oracle and Amazon Linux; for Ubuntu 22.04, 24.04 and 26.04 the fixed kernel is in &lt;code&gt;-updates&lt;/code&gt; but without a USN, so default automatic updates do not install it; they are still missing for Ubuntu 20.04, where they will arrive through Pro. It is not in the CISA KEV catalog and Anthropic&apos;s exploit was not published with its article, but the race can be retried. The nftables rule is a stopgap to reach the maintenance window: it drops only packets with IP options, which ordinary traffic does not carry; the new kernel and the reboot remain the only fix, and the proof is in the changelog, not in &lt;code&gt;uname -r&lt;/code&gt;. If a NIS2 client asks how you handle patches, this case is a good example of a &lt;a href=&quot;/en/changelog/nis2-suppliers-what-to-prepare&quot;&gt;vulnerability plan&lt;/a&gt; to tell with dates and advisories.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want us to update and reboot your servers, with the firewall stopgap in the meantime?&quot; text=&quot;We verify the running kernel on every machine, apply the nftables rule where needed, update and reboot in an agreed window, check the changelog after the reboot and leave you a report with versions and advisories. We manage Linux servers for SMEs, firms and agencies.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.cve.org/CVERecord?id=CVE-2026-98432&quot;&gt;CVE.org, record CVE-2026-98432 (CNA: Linux kernel)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/torvalds/linux/commit/e3f33b0a1d89d738e2b913dab519226eaf76e15b&quot;&gt;Linux, commit e3f33b0 &quot;ipv4: free inet_opt and ireq_opt after an RCU grace period&quot; (GitHub mirror)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.anthropic.com/research/discovering-vulnerabilities-with-claude&quot;&gt;Anthropic, &quot;Discovering vulnerabilities with Claude&quot; (27 October 2026)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://access.redhat.com/security/cve/CVE-2026-98432&quot;&gt;Red Hat, CVE-2026-98432&lt;/a&gt; and &lt;a href=&quot;https://access.redhat.com/security/vulnerabilities/RHSB-2026-016&quot;&gt;bulletin RHSB-2026-016 with the nftables mitigation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://almalinux.org/blog/2026-10-30-cve-2026-98432/&quot;&gt;AlmaLinux, &quot;CVE-2026-98432: Patched kernels released&quot; (30 October, updated 2 November)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://apollo.build.resf.org/api/v3/advisories/RLSA-2026:93414&quot;&gt;Rocky Linux, errata RLSA-2026:93414&lt;/a&gt;, &lt;a href=&quot;https://apollo.build.resf.org/api/v3/advisories/RLSA-2026:93412&quot;&gt;RLSA-2026:93412&lt;/a&gt; and &lt;a href=&quot;https://apollo.build.resf.org/api/v3/advisories/RLSA-2026:93413&quot;&gt;RLSA-2026:93413&lt;/a&gt; (Apollo API)&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.cloudlinux.com/cve-2026-98432-linux-kernel-ipv4-tcp-flaw-status-for-cloudlinux&quot;&gt;CloudLinux, CVE-2026-98432 status and KernelCare&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://ubuntu.com/security/CVE-2026-98432&quot;&gt;Ubuntu, CVE-2026-98432&lt;/a&gt; and &lt;a href=&quot;https://ubuntu.com/blog/fixes-available-in-proposed-pocket-for-cve-2026-98432&quot;&gt;&quot;Fixes available in -proposed pocket for CVE-2026-98432&quot; (2 November)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://api.launchpad.net/1.0/ubuntu/+archive/primary?ws.op=getPublishedSources&amp;amp;source_name=linux&amp;amp;exact_match=true&amp;amp;pocket=Updates&amp;amp;status=Published&amp;amp;distro_series=https://api.launchpad.net/1.0/ubuntu/noble&quot;&gt;Launchpad API, linux source package published in noble-updates&lt;/a&gt; (same query for jammy and resolute)&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://ubuntu.com/about/release-cycle&quot;&gt;Ubuntu, release cycle and support dates&lt;/a&gt; and &lt;a href=&quot;https://ubuntu.com/pro&quot;&gt;Ubuntu Pro&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://security-tracker.debian.org/tracker/CVE-2026-98432&quot;&gt;Debian Security Tracker, CVE-2026-98432&lt;/a&gt;, &lt;a href=&quot;https://lists.debian.org/debian-security-announce/2026/msg00482.html&quot;&gt;DSA-6568-1&lt;/a&gt; and &lt;a href=&quot;https://wiki.debian.org/LTS&quot;&gt;Debian LTS, support dates&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.suse.com/security/cve/CVE-2026-98432.html&quot;&gt;SUSE, CVE-2026-98432&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://explore.alas.aws.amazon.com/CVE-2026-98432.html&quot;&gt;Amazon Linux, CVE-2026-98432&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://linux.oracle.com/cve/CVE-2026-98432.html&quot;&gt;Oracle Linux, CVE-2026-98432&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.openwall.com/lists/oss-security/2026/10/30/1&quot;&gt;oss-security, Go Security Team: &quot;Protecting against CVE-2026-98432 when using Go programs&quot;&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.cisa.gov/known-exploited-vulnerabilities-catalog&quot;&gt;CISA, Known Exploited Vulnerabilities Catalog&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc7126.html&quot;&gt;RFC 7126, recommendations on filtering IPv4 packets containing options&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html&quot;&gt;AWS, security group rules&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.docker.com/engine/network/packet-filtering-firewalls/&quot;&gt;Docker, Packet filtering and firewalls&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>CVE-2026-98432: the firewall stopgap while you wait for the kernel, what it can break and how to test it</title><link>https://initd.it/en/changelog/cve-2026-98432-firewall-workaround-nftables</link><guid isPermaLink="true">https://initd.it/en/changelog/cve-2026-98432-firewall-workaround-nftables</guid><description>The nftables, iptables and ufw rule that drops TCP packets with IP options against CVE-2026-98432: Red Hat and AlmaLinux variants, persistence, what it can break and how to test it safely first.</description><pubDate>Fri, 06 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&lt;strong&gt;CVE-2026-98432&lt;/strong&gt; is a &lt;em&gt;use-after-free&lt;/em&gt; in the Linux kernel code that accepts TCP connections over IPv4: a SYN carrying &lt;strong&gt;IP options&lt;/strong&gt;, retransmitted while the connection completes, makes the kernel read memory it has already freed. The kernel CVE team published it on 15 October 2026 with a 9.8 score, and as of 6 November (status verified at 12:12 UTC) fixed kernels exist for Debian, RHEL with AlmaLinux and Rocky, CloudLinux, SUSE, Oracle and Amazon Linux, while for Ubuntu 22.04, 24.04 and 26.04 they sit in &lt;code&gt;-updates&lt;/code&gt; with no USN yet. Who is affected, under which conditions and how to update is in &lt;a href=&quot;/en/changelog/cve-2026-98432-linux-kernel-tcp-what-to-do&quot;&gt;the article on the flaw&lt;/a&gt;; here we only talk about the stopgap.&lt;/p&gt;
&lt;p&gt;The stopgap is a firewall rule that drops IPv4 TCP packets with IP options, published by Red Hat and by AlmaLinux for those who cannot reboot right away. Before loading it in production the right question is: what stops working? Below: the rule in its nftables, iptables and ufw variants, the tests we ran in a Debian 13 container and on a Docker host, the cases where it pays to stop and think, and the other documented mitigations with their limits.&lt;/p&gt;
&lt;h2&gt;The rule: drop IPv4 TCP packets with IP options&lt;/h2&gt;
&lt;p&gt;Red Hat in bulletin RHSB-2026-016 and AlmaLinux on its blog publish the same idea: drop IPv4 TCP packets whose header is longer than 20 bytes. In nftables that is &lt;code&gt;ip hdrlength &amp;gt; 5&lt;/code&gt;, because RFC 791 measures the header in 32-bit words: 5 without options, up to 15 (60 bytes) with them. Ubuntu&apos;s CVE page hosts a community contribution with a similar rule, which warns that it &quot;reduces the risk but does not fully prevent exploitation&quot;; the Ubuntu Security Team, in its blog post of 2 November, writes that &quot;security updates are the only appropriate mitigation&quot;, and Red Hat presents the rule as a reduction of exposure, not full prevention. Nobody guarantees it stops an exploit, and neither do we: what we verified is what it does to traffic.&lt;/p&gt;
&lt;p&gt;The two variants differ in where they hook. Red Hat uses &lt;code&gt;table inet&lt;/code&gt; and &lt;code&gt;hook input&lt;/code&gt; at priority -310 (rule &lt;code&gt;ip protocol tcp ip hdrlength &amp;gt; 5 counter drop&lt;/code&gt;), AlmaLinux &lt;code&gt;table ip&lt;/code&gt; and &lt;code&gt;hook prerouting&lt;/code&gt; at priority -300. The &lt;code&gt;prerouting&lt;/code&gt; hook sees all incoming traffic, &lt;code&gt;input&lt;/code&gt; only traffic addressed to the machine (nftables wiki), and ports published by Docker are diverted in the &lt;code&gt;nat&lt;/code&gt; table before they reach &lt;code&gt;INPUT&lt;/code&gt; (Docker documentation): only &lt;code&gt;prerouting&lt;/code&gt; covers them, and AlmaLinux says so: the rule protects the host and the containers that receive their traffic through it. In exchange &lt;code&gt;prerouting&lt;/code&gt; also sees forwarded traffic, if the machine acts as a router. AlmaLinux&apos;s variant, in the file &lt;code&gt;/etc/cve-2026-98432.nft&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;table ip cve_2026_98432 {
	chain prerouting {
		type filter hook prerouting priority -300; policy accept;
		meta l4proto tcp ip hdrlength &amp;gt; 5 counter drop
	}
}
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;sudo nft -c -f /etc/cve-2026-98432.nft
sudo nft -f /etc/cve-2026-98432.nft
sudo nft list table ip cve_2026_98432
sudo nft delete table ip cve_2026_98432
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The four commands check the syntax, load, show and remove the table; &lt;code&gt;nft list table&lt;/code&gt; also prints the counter of dropped packets. We ran them in a Debian 13 container with nftables 1.1.3: the table loads, lists, deletes and coexists with Debian&apos;s default &lt;code&gt;inet filter&lt;/code&gt; table. To protect only the machine&apos;s own services, write &lt;code&gt;hook input&lt;/code&gt; instead of &lt;code&gt;hook prerouting&lt;/code&gt; in the same file: &lt;code&gt;nft -c -f&lt;/code&gt; accepts that form too.&lt;/p&gt;
&lt;h2&gt;Surviving a reboot, iptables and ufw&lt;/h2&gt;
&lt;p&gt;The table does not survive a reboot, as both AlmaLinux and Red Hat write. On Debian and Ubuntu &lt;code&gt;nftables.service&lt;/code&gt; runs &lt;code&gt;nft -f /etc/nftables.conf&lt;/code&gt;: add &lt;code&gt;include &quot;/etc/cve-2026-98432.nft&quot;&lt;/code&gt; at the end of that file, check with &lt;code&gt;nft -c -f /etc/nftables.conf&lt;/code&gt; and enable the service. Tested: Debian 13&apos;s default file starts with &lt;code&gt;flush ruleset&lt;/code&gt; and defines an empty &lt;code&gt;inet filter&lt;/code&gt; table, and with the &lt;code&gt;include&lt;/code&gt; at the end &lt;code&gt;nft -f /etc/nftables.conf&lt;/code&gt; loads both tables. On RHEL and its clones the service reads &lt;code&gt;/etc/sysconfig/nftables.conf&lt;/code&gt; instead (unit file read on AlmaLinux 9). Once the fixed kernel is running, remove the &lt;code&gt;include&lt;/code&gt; line and delete the table.&lt;/p&gt;
&lt;p&gt;With iptables there is no IP options module: on Debian 13, iptables 1.8.11 answers &quot;Couldn&apos;t load match &apos;ipv4options&apos;: No such file or directory&quot;. The &lt;code&gt;u32&lt;/code&gt; module, which compares the first bytes of the packet, works: &lt;code&gt;0&amp;gt;&amp;gt;24&amp;amp;0xF&lt;/code&gt; isolates the low four bits of the first byte, that is the IP header length, and &lt;code&gt;6:15&lt;/code&gt; takes every value above 5:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sudo iptables -I INPUT -p tcp -m u32 --u32 &quot;0&amp;gt;&amp;gt;24&amp;amp;0xF=6:15&quot; -j DROP
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Tested: with the rule loaded a local HTTP request answers 200, a SYN with the record route option gets no reply and the counter shows one packet; &lt;code&gt;iptables -D INPUT&lt;/code&gt; with the same arguments removes it. It sits in the &lt;code&gt;INPUT&lt;/code&gt; chain, so like Red Hat&apos;s variant it does not see ports published by Docker. With ufw the same line goes into &lt;code&gt;/etc/ufw/before.rules&lt;/code&gt;, in the &lt;code&gt;ufw-before-input&lt;/code&gt; chain: we verified that &lt;code&gt;iptables-restore --test&lt;/code&gt; accepts the file with the added line (ufw 0.36.2), not the service reload, which does not run in a container.&lt;/p&gt;
&lt;p&gt;What no variant covers: traffic between containers on the same host, which AlmaLinux says &quot;may bypass&quot; the rule and which Red Hat, for pod-to-pod traffic in OVN-Kubernetes, declares not filtered. We saw it too: on a Docker host without the &lt;code&gt;br_netfilter&lt;/code&gt; module, a SYN with the record route option sent from one container to another on the same bridge never touched the counter of the &lt;code&gt;prerouting&lt;/code&gt; rule. A filter at the network boundary in front of the cluster has no such limit (Red Hat again).&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Need to keep a server up that you cannot reboot before the maintenance window?&quot; text=&quot;We load the rule in observation mode, read counter and log for a few days, switch to drop only where the numbers allow it and schedule the kernel update and reboot out of hours.&quot; button=&quot;Ask for an intervention →&quot;}&lt;/p&gt;
&lt;h2&gt;What the rule can break, and when it is a good stopgap&lt;/h2&gt;
&lt;p&gt;The right question before loading it: &quot;if I drop TCP packets with IP options, what stops working?&quot;. Short answer: in ordinary traffic, nothing we could find, measured rather than assumed. The long answer, with tests, limits and the cases where it pays to stop, is below.&lt;/p&gt;
&lt;h3&gt;IP options and TCP options are not the same thing&lt;/h3&gt;
&lt;p&gt;This is the most likely mix-up. &lt;strong&gt;IP options&lt;/strong&gt; live in the IPv4 header, which is normally 20 bytes and grows to 60 with options (RFC 791). &lt;strong&gt;TCP options&lt;/strong&gt; (MSS, SACK, timestamps, window scale) live in the TCP header, further into the packet, and are present in practically every connection: the rule never even looks at them, because &lt;code&gt;ip hdrlength&lt;/code&gt; reads the IP header only. The nmap guide puts it in one line: unlike TCP options, IP options are &quot;rarely seen due to practicality and security concerns&quot;.&lt;/p&gt;
&lt;p&gt;We tested it in the container with the rule in observation mode only (&lt;code&gt;counter&lt;/code&gt; without &lt;code&gt;drop&lt;/code&gt;, the file is further down): a local HTTP server on port 8080, two requests with &lt;code&gt;curl&lt;/code&gt;, counter stuck at zero. The SYN captured by tcpdump is 60 bytes long, with a 20-byte IP header and &lt;code&gt;options [mss 65495,sackOK,TS val ...,nop,wscale 10]&lt;/code&gt; all in the TCP header. Then a SYN built on purpose with the &quot;record route&quot; IP option:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;sudo hping3 -S -p 8080 -c 1 --rroute 127.0.0.1
sudo nft list table ip cve_2026_98432
sudo tcpdump -ni lo -v &apos;tcp and ip[0] &amp;amp; 0xf &amp;gt; 5&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The counter goes up and tcpdump shows &lt;code&gt;options (RR ...)&lt;/code&gt; in the IP header: &lt;code&gt;ip[0] &amp;amp; 0xf&lt;/code&gt; reads the header length field, and the pcap-filter manual uses &lt;code&gt;ip[0] &amp;amp; 0xf != 5&lt;/code&gt; for all IPv4 packets with options (5 is the minimum, so &lt;code&gt;&amp;gt; 5&lt;/code&gt; selects the same packets). Mind the numbers: every probe on loopback counts three packets, because the kernel copies the options into the SYN-ACK and also into the RST with which, on hping3&apos;s side, it rejects that SYN-ACK (hping3 sends the SYN from a raw socket, without opening a connection).&lt;/p&gt;
&lt;h3&gt;Who actually uses IP options&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Option&lt;/th&gt;
&lt;th&gt;Who uses it&lt;/th&gt;
&lt;th&gt;How common&lt;/th&gt;
&lt;th&gt;With the rule&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Source routing (LSRR, SSRR): the sender dictates the path&lt;/td&gt;
&lt;td&gt;&lt;code&gt;traceroute -g&lt;/code&gt;, &lt;code&gt;nmap --ip-options L&lt;/code&gt; or &lt;code&gt;S&lt;/code&gt;, &lt;code&gt;hping3 --lsrr&lt;/code&gt; or &lt;code&gt;--ssrr&lt;/code&gt; (listed by &lt;code&gt;hping3 --help&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;Very rare: the traceroute manual warns that &quot;most routers have disabled source routing for security reasons&quot;, and RFC 7126 says to drop it by default&lt;/td&gt;
&lt;td&gt;Nothing changes: the kernel already drops it before TCP sees it (test below)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Record Route and Timestamp: record the path or the times&lt;/td&gt;
&lt;td&gt;&lt;code&gt;ping -R&lt;/code&gt;, &lt;code&gt;ping -T&lt;/code&gt;, &lt;code&gt;hping3 --rroute&lt;/code&gt;, &lt;code&gt;nmap --ip-options R&lt;/code&gt; or &lt;code&gt;T&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Rare: the ping manual warns that &quot;Many hosts ignore or discard this option&quot;, and RFC 7126 recommends dropping both Record Route and Timestamp by default&lt;/td&gt;
&lt;td&gt;Only TCP tests with these options are dropped; &lt;code&gt;ping&lt;/code&gt; travels over ICMP, which the rule does not look at&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CIPSO: a security label in the packet&lt;/td&gt;
&lt;td&gt;NetLabel, which adds the label as an IP option to outgoing packets (kernel documentation)&lt;/td&gt;
&lt;td&gt;Networks with security labels; RFC 7126 asks not to drop CIPSO by default and states that &quot;No routers or firewalls are known to support this option&quot;&lt;/td&gt;
&lt;td&gt;AlmaLinux warns not to use the rule if your network relies on CIPSO; with NetLabel compiled in but no domain configured the kernel already rejects these packets (test below)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Router Alert and Quick-Start&lt;/td&gt;
&lt;td&gt;Specific protocols, described in RFC 7126&lt;/td&gt;
&lt;td&gt;RFC 7126 recommends ignoring them by default and, for Router Alert, dropping it in unsafe environments&lt;/td&gt;
&lt;td&gt;Dropped if they arrive inside a TCP packet&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;Source routing, the most cited case: the kernel accepts a source-routed packet only if &lt;code&gt;net.ipv4.conf.all.accept_source_route&lt;/code&gt; and the interface value are both 1 (the &lt;code&gt;IN_DEV_SOURCE_ROUTE&lt;/code&gt; macro in &lt;code&gt;inetdevice.h&lt;/code&gt; ANDs them, &lt;code&gt;ip_input.c&lt;/code&gt; drops the packet when it is false, and the sysctl documentation gives a host&apos;s default as false). In the container every value was 0. Test with the rule in observation mode and two SYNs built with scapy: the one with record route gets its SYN-ACK, the same SYN with loose source route gets nothing. CIPSO, same test: on a kernel with NetLabel compiled in (&lt;code&gt;CONFIG_NETLABEL=y&lt;/code&gt;, read in the Debian 13, Ubuntu 26.04 and AlmaLinux 9 kernels) but with no NetLabel domain configured, a SYN with a CIPSO option gets an ICMP &quot;parameter problem&quot; (type 12), sent by &lt;code&gt;ip_options.c&lt;/code&gt; when option parsing fails, and the &lt;code&gt;IpInHdrErrors&lt;/code&gt; counter in &lt;code&gt;/proc/net/snmp&lt;/code&gt; goes up, as &lt;code&gt;ip_input.c&lt;/code&gt; does. On a kernel built without NetLabel the check on the option is only structural and the packet gets through. Labeled IPsec is unrelated: its label travels in the IKEv2 negotiation (RFC 9478), not in IP options.&lt;/p&gt;
&lt;p&gt;What the dropped side sees: nothing. &lt;code&gt;drop&lt;/code&gt; sends no error, the client retransmits the SYN and gives up after six retransmissions, 131 seconds with the defaults documented for current kernels (&lt;code&gt;tcp_syn_retries&lt;/code&gt;): in our tests &lt;code&gt;hping3 -S --rroute&lt;/code&gt; against the server in drop mode ends with &quot;100% packet loss&quot;, not with a refusal. How many IP options arrive from the internet: RFC 7126 speaks of a &quot;widespread practice of blocking IPv4 optioned packets&quot; and points to the study by Fonseca et al. (Berkeley, 2005), which found that &quot;approximately half of Internet paths drop packets with options&quot;, with the drops concentrated in a minority of edge networks. We know of no more recent measurements, and we made none on your server: hence the observation phase.&lt;/p&gt;
&lt;h3&gt;The common setups, one by one&lt;/h3&gt;
&lt;p&gt;The rule does not look at the port: it applies to any IPv4 TCP service, and what changes from one case to the next is whether the client asks its kernel for IP options. For the cases below we either measured it or have a source that says it.&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Setup&lt;/th&gt;
&lt;th&gt;Verdict&lt;/th&gt;
&lt;th&gt;Why (test or source)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Web, also behind a CDN or &lt;a href=&quot;/en/changelog/nginx-reverse-proxy&quot;&gt;reverse proxy&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Negligible&lt;/td&gt;
&lt;td&gt;The HTTP traffic in our tests carries no IP options: two &lt;code&gt;curl&lt;/code&gt; requests never touch the counter. The proxy is still a host with an open IPv4 TCP port: the rule belongs there too&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href=&quot;/en/changelog/wireguard-vpn&quot;&gt;WireGuard&lt;/a&gt; VPN&lt;/td&gt;
&lt;td&gt;No impact, and it also covers the tunnel&apos;s clients&lt;/td&gt;
&lt;td&gt;Tested with a tunnel between two network namespaces and the rule in &lt;code&gt;prerouting&lt;/code&gt; on the server: &lt;code&gt;curl&lt;/code&gt; inside the tunnel answers 200 with the counter still, a SYN with record route inside the tunnel is counted and, with &lt;code&gt;drop&lt;/code&gt;, dropped&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Docker with published ports&lt;/td&gt;
&lt;td&gt;No impact on ordinary traffic, published ports covered by &lt;code&gt;prerouting&lt;/code&gt;&lt;/td&gt;
&lt;td&gt;Tested on a Docker host (docker:dind image, nftables 1.1.6) with nginx published on 8080: &lt;code&gt;curl&lt;/code&gt; from outside answers 200 with the counter still, a SYN with record route is counted in observation mode and dropped with &lt;code&gt;drop&lt;/code&gt;, while &lt;code&gt;curl&lt;/code&gt; keeps answering. The same SYN between two containers on the same bridge never touched the counter (host without &lt;code&gt;br_netfilter&lt;/code&gt;): that is the traffic AlmaLinux and Red Hat warn is not covered&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Routers, NAT, transit firewalls&lt;/td&gt;
&lt;td&gt;Caution&lt;/td&gt;
&lt;td&gt;&lt;code&gt;prerouting&lt;/code&gt; is also crossed by forwarded traffic (nftables wiki): with &lt;code&gt;drop&lt;/code&gt; you also discard transit traffic with options, which RFC 7126 recommends anyway for source routing and Timestamp. To protect only the router&apos;s own services use &lt;code&gt;hook input&lt;/code&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;IPv6&lt;/td&gt;
&lt;td&gt;Nothing changes&lt;/td&gt;
&lt;td&gt;&lt;code&gt;table ip&lt;/code&gt; applies to IPv4 only; the commit says IPv6 is not affected by the first issue and AlmaLinux that &quot;IPv6 traffic does not need the rule&quot;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;Kubernetes, layer 4 balancers and OpenVPN we did not test and do not judge: try in staging.&lt;/p&gt;
&lt;h3&gt;Observe first, then drop&lt;/h3&gt;
&lt;p&gt;The safe way to introduce it is in two steps. First, the same rule without &lt;code&gt;drop&lt;/code&gt;, with the counter and a limited log, in &lt;code&gt;/etc/cve-2026-98432-osserva.nft&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;table ip cve_2026_98432 {
	chain prerouting {
		type filter hook prerouting priority -300; policy accept;
		meta l4proto tcp ip hdrlength &amp;gt; 5 counter limit rate 10/minute log prefix &quot;cve-2026-98432 &quot;
	}
}
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;sudo nft -f /etc/cve-2026-98432-osserva.nft
sudo nft list table ip cve_2026_98432
sudo journalctl -k | grep cve-2026-98432
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;After a day (a week, if traffic is light) the counter tells you how many TCP packets with IP options arrived and the log tells you from which addresses; the &lt;code&gt;limit&lt;/code&gt; keeps the log to about ten lines per minute and, per the nft manual, the lines go to the kernel log, where &lt;code&gt;journalctl -k&lt;/code&gt; reads them. In the container we verified loading and counting, not the log lines: by default only the main network namespace writes to the kernel log (&lt;code&gt;nf_log_all_netns&lt;/code&gt;, kernel documentation), and that is the one a real server uses. The log records IP addresses, that is personal data: keep it &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;to the minimum&lt;/a&gt;. Like the drop rule, it does not survive a reboot: the same &lt;code&gt;include&lt;/code&gt; applies. Counter at zero, or only probes: move to &lt;code&gt;drop&lt;/code&gt; with &lt;code&gt;nft delete table ip cve_2026_98432&lt;/code&gt; and &lt;code&gt;nft -f /etc/cve-2026-98432.nft&lt;/code&gt;. Counter rising from addresses you recognise (a monitoring system, a partner, a labelled network): before dropping, ask what they are.&lt;/p&gt;
&lt;h3&gt;Who can use it with peace of mind&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Situation&lt;/th&gt;
&lt;th&gt;Verdict&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Web, mail, database or SSH servers, on the internet or on the LAN, with no special requirements&lt;/td&gt;
&lt;td&gt;Use it, after the observation phase: the rule does not look at the service, and the counter tells you whether any client uses IP options&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Docker hosts with published ports, WireGuard servers&lt;/td&gt;
&lt;td&gt;Use it (&lt;code&gt;prerouting&lt;/code&gt; variant): tested, it covers published ports and tunnel clients, not traffic between containers&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Routers, NAT, transit firewalls&lt;/td&gt;
&lt;td&gt;Caution: &lt;code&gt;input&lt;/code&gt; variant, or accept dropping transit traffic with options too&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Networks with monitoring or scanners that use IP options over TCP (&lt;code&gt;hping3 --rroute&lt;/code&gt;, &lt;code&gt;nmap --ip-options&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;Caution: those tests will fail by timeout, warn whoever runs them&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Networks with CIPSO labels (NetLabel), legacy or industrial networks with source routing&lt;/td&gt;
&lt;td&gt;Not blindly: AlmaLinux says not to use it with CIPSO; decide with whoever manages the network&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;The honest verdict: IP options in ordinary traffic are rare, the kernel already drops source routing and, by the only measurement we know of, from 2005, about half of internet paths dropped packets with options: for the vast majority of servers the rule is a reasonable bridge to the maintenance window. It remains a bridge: it reduces the risk, it does not remove it, and the fixed kernel with a reboot is the only fix. If you would rather have someone else handle that window, the &lt;a href=&quot;/en/services/linux-administration&quot;&gt;managed server&lt;/a&gt; plan starts at €89 per month and includes security patches and scheduled updates.&lt;/p&gt;
&lt;h2&gt;The other documented mitigations, with their limits&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Disabling MPTCP&lt;/strong&gt; (&lt;code&gt;net.mptcp.enabled=0&lt;/code&gt;, persisted in &lt;code&gt;/etc/sysctl.d/&lt;/code&gt;) closes only the route Anthropic demonstrated, which used a &lt;em&gt;Multipath TCP&lt;/em&gt; listener. The kernel default is 1 (MPTCP sysctl documentation), read on an Ubuntu 26.04 host and in a fresh network namespace; AlmaLinux ships it at 0 and Red Hat writes that it is disabled in RHEL&apos;s default configuration, but both repeat that MPTCP is not a precondition for the flaw and that disabling it is not enough. The documentation talks about creating MPTCP sockets, not about those already open: restart the services that have an MPTCP listener (&lt;code&gt;ss -Mlnp&lt;/code&gt; lists them). Since 1.24, Go programs open listeners with MPTCP by default on Linux, and the Go security team calls per-program disabling &quot;a fragile mitigation&quot;, because one forgotten listener is enough.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;net.ipv4.tcp_migrate_req=0&lt;/code&gt;&lt;/strong&gt; is already the default (IP sysctl documentation): check you did not change it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Livepatch.&lt;/strong&gt; CloudLinux lists KernelCare with the fix for the CloudLinux 7h, 8 and 9 kernels since 2 November and for CloudLinux 10 since the 3rd, applied with &lt;code&gt;kcarectl --update&lt;/code&gt; and verified with &lt;code&gt;kcarectl --patch-info&lt;/code&gt; grepping for the CVE: having no KernelCare, we did not run these commands. SUSE&apos;s CVE page lists &lt;code&gt;kernel-livepatch&lt;/code&gt; packages for SLES 15 SP4-SP7; Canonical&apos;s blog post of 2 November does not mention Livepatch.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;init_on_free=1&lt;/code&gt;&lt;/strong&gt; was proposed on oss-security, and on 2 November Sultan Alsawaf of CIQ&apos;s kernel team replied that it &quot;doesn&apos;t do anything meaningful against this CVE&quot;: the pointers the attacker needs leak from live objects next to the freed one, not from the freed object&apos;s own contents, so zeroing freed memory changes nothing meaningful.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;None of these replaces the new kernel and the reboot, and AlmaLinux says it of its own interim steps: &quot;Neither step is a fix&quot;. They get you to the maintenance window, they do not let you skip it.&lt;/p&gt;
&lt;h2&gt;In summary&lt;/h2&gt;
&lt;p&gt;The stopgap for CVE-2026-98432 is an nftables rule (or iptables &lt;code&gt;u32&lt;/code&gt;) that drops IPv4 TCP packets with IP options, in Red Hat&apos;s &lt;code&gt;input&lt;/code&gt; variant or AlmaLinux&apos;s &lt;code&gt;prerouting&lt;/code&gt; variant: the latter also covers ports published by Docker and the clients of a WireGuard VPN, as we measured, while traffic between containers on the same host may bypass them, as AlmaLinux warns and as we saw on a Docker host. IP options in ordinary traffic are rare and the kernel already drops source routing; those who can lose out are diagnostic tools that use record route or timestamp over TCP, transit routers and networks with CIPSO labels. Introduce it first in observation mode and then in drop mode, with the &lt;code&gt;include&lt;/code&gt; for reboots and the removal once the fixed kernel runs: the other mitigations cover less or nothing, and the new kernel with a reboot remains the only fix.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want the stopgap applied with method, and removed at the right time?&quot; text=&quot;We load the rule in observation mode on your servers, read counters and logs, switch to drop where the numbers allow it, make everything persistent and remove it after the reboot with the fixed kernel, leaving you the files and a report. We manage Linux servers for SMEs, firms and agencies.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.cve.org/CVERecord?id=CVE-2026-98432&quot;&gt;CVE.org, record CVE-2026-98432 (CNA: Linux kernel)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/torvalds/linux/commit/e3f33b0a1d89d738e2b913dab519226eaf76e15b&quot;&gt;Linux, commit e3f33b0 &quot;ipv4: free inet_opt and ireq_opt after an RCU grace period&quot; (GitHub mirror)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://access.redhat.com/security/vulnerabilities/RHSB-2026-016&quot;&gt;Red Hat, bulletin RHSB-2026-016 with the nftables mitigation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://almalinux.org/blog/2026-10-30-cve-2026-98432/&quot;&gt;AlmaLinux, &quot;CVE-2026-98432: Patched kernels released&quot; (30 October, updated 2 November)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://ubuntu.com/security/CVE-2026-98432&quot;&gt;Ubuntu, CVE-2026-98432 (with the community contribution on the nftables rule)&lt;/a&gt; and &lt;a href=&quot;https://ubuntu.com/blog/fixes-available-in-proposed-pocket-for-cve-2026-98432&quot;&gt;&quot;Fixes available in -proposed pocket for CVE-2026-98432&quot; (2 November)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.cloudlinux.com/cve-2026-98432-linux-kernel-ipv4-tcp-flaw-status-for-cloudlinux&quot;&gt;CloudLinux, CVE-2026-98432 status and KernelCare&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.suse.com/security/cve/CVE-2026-98432.html&quot;&gt;SUSE, CVE-2026-98432&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.anthropic.com/research/discovering-vulnerabilities-with-claude&quot;&gt;Anthropic, &quot;Discovering vulnerabilities with Claude&quot; (27 October 2026)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.openwall.com/lists/oss-security/2026/10/30/1&quot;&gt;oss-security, Go Security Team: &quot;Protecting against CVE-2026-98432 when using Go programs&quot;&lt;/a&gt; and &lt;a href=&quot;https://www.openwall.com/lists/oss-security/2026/11/03/1&quot;&gt;Sultan Alsawaf (CIQ) on init_on_free=1&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc7126.html&quot;&gt;RFC 7126, recommendations on filtering IPv4 packets containing options&lt;/a&gt;, &lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc791.html&quot;&gt;RFC 791, Internet Protocol&lt;/a&gt; and &lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc9478.html&quot;&gt;RFC 9478, Labeled IPsec Traffic Selector Support for IKEv2&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www2.eecs.berkeley.edu/Pubs/TechRpts/2005/EECS-2005-24.html&quot;&gt;Fonseca, Porter, Katz, Shenker, Stoica, &quot;IP Options are not an option&quot;, UC Berkeley EECS-2005-24&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.kernel.org/networking/mptcp-sysctl.html&quot;&gt;Linux kernel, MPTCP sysctl&lt;/a&gt;, &lt;a href=&quot;https://docs.kernel.org/networking/ip-sysctl.html&quot;&gt;IP sysctl (accept_source_route, tcp_syn_retries, tcp_migrate_req)&lt;/a&gt; and &lt;a href=&quot;https://docs.kernel.org/networking/netfilter-sysctl.html&quot;&gt;netfilter sysctl (nf_log_all_netns)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/torvalds/linux/blob/master/net/ipv4/ip_input.c&quot;&gt;Linux kernel, net/ipv4/ip_input.c&lt;/a&gt;, &lt;a href=&quot;https://github.com/torvalds/linux/blob/master/net/ipv4/ip_options.c&quot;&gt;net/ipv4/ip_options.c&lt;/a&gt;, &lt;a href=&quot;https://github.com/torvalds/linux/blob/master/include/linux/inetdevice.h&quot;&gt;include/linux/inetdevice.h (IN_DEV_SOURCE_ROUTE macro)&lt;/a&gt;, &lt;a href=&quot;https://github.com/torvalds/linux/blob/master/include/net/cipso_ipv4.h&quot;&gt;include/net/cipso_ipv4.h (cipso_v4_validate without CONFIG_NETLABEL)&lt;/a&gt; and &lt;a href=&quot;https://docs.kernel.org/netlabel/cipso_ipv4.html&quot;&gt;NetLabel: CIPSO/IPv4 engine&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://man7.org/linux/man-pages/man8/traceroute.8.html&quot;&gt;man traceroute(8)&lt;/a&gt;, &lt;a href=&quot;https://man7.org/linux/man-pages/man8/ping.8.html&quot;&gt;man ping(8)&lt;/a&gt;, &lt;a href=&quot;https://manpages.debian.org/trixie/hping3/hping3.8.en.html&quot;&gt;man hping3(8)&lt;/a&gt;, &lt;a href=&quot;https://nmap.org/book/man-bypass-firewalls-ids.html&quot;&gt;Nmap Reference Guide, --ip-options&lt;/a&gt;, &lt;a href=&quot;https://www.tcpdump.org/manpages/pcap-filter.7.html&quot;&gt;man pcap-filter(7)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.netfilter.org/projects/nftables/manpage.html&quot;&gt;nftables, man nft(8)&lt;/a&gt;, &lt;a href=&quot;https://wiki.nftables.org/wiki-nftables/index.php/Netfilter_hooks&quot;&gt;nftables wiki, Netfilter hooks&lt;/a&gt; and &lt;a href=&quot;https://docs.docker.com/engine/network/packet-filtering-firewalls/&quot;&gt;Docker, Packet filtering and firewalls&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>DANE and DNSSEC for Email: SMTP Encryption Guaranteed by DNS</title><link>https://initd.it/en/changelog/dane-tlsa-smtp-security</link><guid isPermaLink="true">https://initd.it/en/changelog/dane-tlsa-smtp-security</guid><description>What DANE is, how TLSA records and DNSSEC make SMTP encryption mandatory between servers without relying on public CAs, and which operational risks it carries.</description><pubDate>Mon, 02 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;In the &lt;a href=&quot;/en/changelog/starttls-stripping-implicit-tls&quot;&gt;article on STARTTLS stripping&lt;/a&gt; we saw that between mail servers encryption stays opportunistic and an attacker can make it disappear. &lt;a href=&quot;/en/changelog/mta-sts-enforce-email-encryption&quot;&gt;MTA-STS&lt;/a&gt; answers with a file over HTTPS and public CA certificates. &lt;strong&gt;DANE&lt;/strong&gt; (&lt;em&gt;DNS-based Authentication of Named Entities&lt;/em&gt;) answers differently: &lt;strong&gt;DNS, signed with DNSSEC, declares which certificate the mail server must present&lt;/strong&gt;, and by its very presence signals that encryption is mandatory.&lt;/p&gt;
&lt;p&gt;For email DANE is defined in RFC 7672 (&lt;em&gt;SMTP Security via Opportunistic DANE TLS&lt;/em&gt;). It does not rely on trust on first connection, but it requires DNSSEC.&lt;/p&gt;
&lt;h2&gt;Two ingredients: DNSSEC and TLSA&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;DNSSEC&lt;/strong&gt; adds cryptographic signatures to DNS: whoever queries can verify that an answer is authentic. RFC 7672 is blunt on this point: without DNSSEC the MX lookup is vulnerable to man-in-the-middle and cache poisoning attacks, and without DNSSEC the server&apos;s certificate cannot be verified securely.&lt;/p&gt;
&lt;p&gt;A &lt;strong&gt;TLSA record&lt;/strong&gt; associates a certificate or public key with a service (host and port). For a receiving mail server the record name is built from the port and the MX host name:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_25._tcp.mail.example.com.  IN  TLSA  3 1 1  &amp;lt;SHA-256 fingerprint of the public key&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The three numbers are (RFC 7671):&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;3&lt;/strong&gt; (&lt;em&gt;DANE-EE&lt;/em&gt;): the server&apos;s own certificate is matched directly against the record, without going through a CA.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;1&lt;/strong&gt; (&lt;em&gt;SPKI&lt;/em&gt;): the fingerprint covers only the public key (&lt;em&gt;SubjectPublicKeyInfo&lt;/em&gt;), not the whole certificate.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;1&lt;/strong&gt; (&lt;em&gt;SHA-256&lt;/em&gt;): the fingerprint algorithm.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;RFC 7672 recommends exactly the &lt;code&gt;3 1 1&lt;/code&gt; combination for email, and discourages records with certificate usage 0 and 1 (PKIX-TA and PKIX-EE). RFC 7671 adds that the key-only fingerprint does not change when a certificate is renewed with the same key, and that with DANE-EE the certificate&apos;s expiry date is ignored: validity comes from the record&apos;s DNSSEC signatures.&lt;/p&gt;
&lt;p&gt;The fingerprint is computed from the certificate in use (command tested on a test certificate):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;openssl x509 -in cert.pem -noout -pubkey \
  | openssl pkey -pubin -outform DER \
  | openssl dgst -sha256 -binary | xxd -p -c 64
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The result, 64 hexadecimal characters, goes in the last field of the record.&lt;/p&gt;
&lt;h2&gt;A real example&lt;/h2&gt;
&lt;p&gt;The &lt;code&gt;mx.ietf.org&lt;/code&gt; server publishes two signed TLSA records (checked on 31 October 2026 with &lt;code&gt;dig +dnssec TLSA _25._tcp.mx.ietf.org&lt;/code&gt;):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_25._tcp.mx.ietf.org.  295  IN  TLSA   3 1 1 E3008A5C0BC1E088...
_25._tcp.mx.ietf.org.  295  IN  TLSA   3 1 1 292481EEE04F9F5C...
_25._tcp.mx.ietf.org.  295  IN  RRSIG  TLSA 13 5 300 ...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The &lt;code&gt;RRSIG&lt;/code&gt; record is the DNSSEC signature. Values are truncated here for readability.&lt;/p&gt;
&lt;h2&gt;How it protects against stripping&lt;/h2&gt;
&lt;p&gt;A sender that supports DANE, before delivering, looks up the MX host&apos;s TLSA while validating DNSSEC:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;If a correctly signed TLSA exists&lt;/strong&gt;, RFC 7672 requires that the sender never delivers unless a TLS session was negotiated with STARTTLS. An attacker who deletes &lt;code&gt;STARTTLS&lt;/code&gt; from the server&apos;s capabilities gets a refusal, not a plaintext delivery: the same signed record proves the server supports TLS.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;If the DNS result is &quot;insecure&quot;&lt;/strong&gt; (the zone is not signed), DANE does not apply and things stay at the previous opportunistic encryption.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;If DNSSEC validation fails&lt;/strong&gt;, the RFC says delivery &lt;strong&gt;must be delayed&lt;/strong&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;That last point is also the main risk, as we see below.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Want to know if your domain is ready for DNSSEC and DANE?&quot; text=&quot;We check zone signing, MX hosts and certificates, and tell you whether DANE pays off or MTA-STS is enough.&quot; button=&quot;Request a check →&quot;}&lt;/p&gt;
&lt;h2&gt;How to publish DANE for inbound mail&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Sign with DNSSEC&lt;/strong&gt; the zone that contains the MX host name.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Publish the TLSA&lt;/strong&gt; &lt;code&gt;3 1 1&lt;/code&gt; for each MX host.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Check&lt;/strong&gt; that the record is signed:&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;dig +dnssec TLSA _25._tcp.mail.example.com
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;If the zone is signed, the answer also contains the &lt;code&gt;RRSIG&lt;/code&gt; record for the TLSA. To see what happens from a sender&apos;s side, Postfix includes &lt;code&gt;posttls-finger&lt;/code&gt;: its documentation lists &lt;code&gt;-l dane&lt;/code&gt; to use the DANE level, &lt;code&gt;-c&lt;/code&gt; to show only TLS information and &lt;code&gt;-L summary&lt;/code&gt; for a one-line summary:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;posttls-finger -c -l dane -Lsummary mail.example.com
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;If your mail is hosted by a provider, the records are those of the provider&apos;s MX host name. Exchange Online, for example, supports DANE for inbound mail with DNSSEC: according to Microsoft&apos;s documentation, the domain needs DNSSEC enabled and a new MX record pointing to a host ending in &lt;code&gt;mx.microsoft&lt;/code&gt;, while the TLSA record is provisioned by Exchange Online.&lt;/p&gt;
&lt;h2&gt;The golden rule: key rotation&lt;/h2&gt;
&lt;p&gt;The TLSA contains the fingerprint of the key. If the certificate is renewed &lt;strong&gt;with a new key&lt;/strong&gt; and the record is not updated, your server no longer matches what is published and DANE senders do not deliver. Certbot&apos;s documentation is clear: by default Certbot generates a new private key at every renewal.&lt;/p&gt;
&lt;p&gt;There are two correct ways:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Reuse the same key&lt;/strong&gt; at every renewal. Certbot has the &lt;code&gt;--reuse-key&lt;/code&gt; option (&quot;When renewing, use the same private key as the existing certificate&quot;). The &lt;code&gt;3 1 1&lt;/code&gt; fingerprint stays valid.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Publish the new key&apos;s record before using it.&lt;/strong&gt; RFC 7672 requires publishing two TLSA records (the current key&apos;s and the new one&apos;s) before using the new key; RFC 7671 specifies doing so at least two TTLs before deploying it. Once the new key is in use, remove the old record.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;With certificates expiring ever sooner, &lt;a href=&quot;/en/changelog/tls-certificates-47-days&quot;&gt;down to 47 days&lt;/a&gt;, this step must be automated.&lt;/p&gt;
&lt;h2&gt;Operational risks&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Invalid DNSSEC.&lt;/strong&gt; If for any reason DNSSEC validation fails, RFC 7672 requires senders to delay delivery. You need monitoring on signature validity.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;TLSA published for a host that does not offer STARTTLS.&lt;/strong&gt; The RFC forbids delivery without a negotiated TLS session: the mail does not arrive.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;MX host name in an unsigned zone&lt;/strong&gt; (for example a provider&apos;s): DANE does not apply.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;TTLs that are too high on TLSA records.&lt;/strong&gt; RFC 7671 recommends TTLs short enough to limit unplanned disruption, because resolvers holding stale records can make deliveries fail after an unplanned key change.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;DANE or MTA-STS?&lt;/h2&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;MTA-STS&lt;/th&gt;
&lt;th&gt;DANE&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Requires DNSSEC&lt;/td&gt;
&lt;td&gt;No&lt;/td&gt;
&lt;td&gt;Yes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;How the server is verified&lt;/td&gt;
&lt;td&gt;certificate signed by a trusted CA, matching name&lt;/td&gt;
&lt;td&gt;fingerprint published in signed DNS (with &lt;code&gt;3 1 1&lt;/code&gt;, no CA)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;First connection&lt;/td&gt;
&lt;td&gt;not protected (the policy must be obtained first)&lt;/td&gt;
&lt;td&gt;protected, because DNSSEC can prove a record does not exist&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What to publish&lt;/td&gt;
&lt;td&gt;two DNS records and a file over HTTPS&lt;/td&gt;
&lt;td&gt;signed zone and TLSA records&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;They are not mutually exclusive: Exchange Online, for example, documents support for both DANE and MTA-STS. Further reading: &lt;a href=&quot;/en/changelog/mta-sts-enforce-email-encryption&quot;&gt;MTA-STS&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;DANE uses DNSSEC to make DNS declare which key the mail server must present; the presence of the signed record makes encryption mandatory for senders that support it, without going through public CAs and without the first-connection limit. The price is managing DNSSEC and keys: a badly done rotation or invalid signatures make mail delivery be delayed.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want DNSSEC and DANE managed without surprises?&quot; text=&quot;We sign zones, publish TLSA records, automate key rotation alongside certificate renewals and monitor signature validity.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc7672.html&quot;&gt;RFC 7672 - SMTP Security via Opportunistic DANE TLS&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc7671.html&quot;&gt;RFC 7671 - The DANE Protocol: Updates and Operational Guidance&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc6698.html&quot;&gt;RFC 6698 - The DNS-Based Authentication of Named Entities (DANE) TLSA&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://learn.microsoft.com/en-us/exchange/security-and-compliance/how-dane-secures-email&quot;&gt;How SMTP DANE works - Microsoft Learn&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://eff-certbot.readthedocs.io/en/stable/using.html&quot;&gt;Certbot - User Guide (--reuse-key)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://manpages.debian.org/unstable/postfix/posttls-finger.1.en.html&quot;&gt;posttls-finger(1) - Debian manpages&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>MTA-STS: How to Force Other Servers to Encrypt the Mail They Send You</title><link>https://initd.it/en/changelog/mta-sts-enforce-email-encryption</link><guid isPermaLink="true">https://initd.it/en/changelog/mta-sts-enforce-email-encryption</guid><description>What MTA-STS is, how to set it up with a DNS record and a file served over HTTPS, and how it protects inbound mail from STARTTLS stripping between servers without requiring DNSSEC.</description><pubDate>Sun, 01 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;In the &lt;a href=&quot;/en/changelog/starttls-stripping-implicit-tls&quot;&gt;article on STARTTLS stripping&lt;/a&gt; we left one problem open: between one mail server and another (port 25) implicit TLS is not practical, and encryption stays opportunistic. The sending server tries to encrypt &quot;if available&quot;; someone in the middle can make it look unavailable.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;MTA-STS&lt;/strong&gt; (&lt;em&gt;Mail Transfer Agent Strict Transport Security&lt;/em&gt;, RFC 8461) is the answer that does not require DNSSEC. The owner of a domain publishes a rule that tells the servers writing to it: &quot;use TLS, to these specific servers, with a valid certificate. Otherwise do not deliver.&quot; You need a DNS record and a file on an HTTPS site.&lt;/p&gt;
&lt;p&gt;An analogy: it is the notice on the door of an apartment building. &quot;Parcels are handed only to the doorman, inside, with ID.&quot; A courier who has read it never leaves a parcel with a stranger on the pavement.&lt;/p&gt;
&lt;h2&gt;How it works&lt;/h2&gt;
&lt;p&gt;MTA-STS has two parts.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;1. A DNS TXT record&lt;/strong&gt; that signals a policy exists:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_mta-sts.example.com.  IN  TXT  &quot;v=STSv1; id=20261101000000Z;&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The &lt;code&gt;id&lt;/code&gt; changes with every policy change: senders use it to know they must download the policy again. Microsoft suggests, for example, using the UTC date and time.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2. A policy file&lt;/strong&gt; served over HTTPS at a fixed address, on the &lt;code&gt;mta-sts&lt;/code&gt; subdomain:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;https://mta-sts.example.com/.well-known/mta-sts.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;version: STSv1
mode: enforce
mx: mail.example.com
mx: backup-mx.example.com
max_age: 1209600
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;mx&lt;/code&gt;: the mail servers allowed to receive for the domain (a wildcard is allowed only on the left, such as &lt;code&gt;*.example.net&lt;/code&gt;). An MX record pointing to an unlisted host fails validation.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;mode&lt;/code&gt;: &lt;code&gt;testing&lt;/code&gt; (if the check fails, mail may still be delivered, and senders that support TLS-RPT send a report), &lt;code&gt;enforce&lt;/code&gt; (if the check fails, &lt;strong&gt;do not deliver&lt;/strong&gt;) or &lt;code&gt;none&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;max_age&lt;/code&gt;: for how many seconds the policy may stay cached at the sender, up to 31557600 (about a year). The RFC recommends values in the range of weeks or more.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;In &lt;code&gt;enforce&lt;/code&gt; mode, the RFC forbids the sender from delivering to a server that is not in the &lt;code&gt;mx&lt;/code&gt; list, does not support STARTTLS or presents an invalid certificate. The certificate must be unexpired, chain to a trusted CA and have a name matching the MX host. These failures must be treated as transient: the message is retried later.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your domain receive mail with no rule about encryption?&quot; text=&quot;We publish MTA-STS and TLS-RPT for your domain, starting in testing and moving to enforce with the reports in hand.&quot; button=&quot;Request a check →&quot;}&lt;/p&gt;
&lt;h2&gt;A real example&lt;/h2&gt;
&lt;p&gt;The &lt;code&gt;gmail.com&lt;/code&gt; domain publishes MTA-STS. Querying DNS and the site (checked on 1 November 2026):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;dig +short TXT _mta-sts.gmail.com
curl -sS https://mta-sts.gmail.com/.well-known/mta-sts.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;pre&gt;&lt;code&gt;&quot;v=STSv1; id=20190429T010101;&quot;

version: STSv1
mode: enforce
mx: smtp.google.com
mx: gmail-smtp-in.l.google.com
mx: *.gmail-smtp-in.l.google.com
max_age: 86400
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;It also publishes a reporting record: &lt;code&gt;_smtp._tls.gmail.com&lt;/code&gt; contains &lt;code&gt;&quot;v=TLSRPTv1;rua=mailto:sts-reports@google.com&quot;&lt;/code&gt;.&lt;/p&gt;
&lt;h2&gt;Reports: TLS-RPT&lt;/h2&gt;
&lt;p&gt;MTA-STS alone works blind: if a certificate expires, senders stop delivering and you do not know. That is why it is paired with &lt;strong&gt;TLS-RPT&lt;/strong&gt; (RFC 8460), a DNS record saying where to send summaries of connection outcomes:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_smtp._tls.example.com.  IN  TXT  &quot;v=TLSRPTv1;rua=mailto:tls-reports@example.com&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;According to RFC 8460 reports are in JSON format (gzip compression is recommended) and normally cover a full day, 00:00 to 24:00 UTC. Among the errors they report are &lt;code&gt;starttls-not-supported&lt;/code&gt;, &lt;code&gt;certificate-expired&lt;/code&gt;, &lt;code&gt;certificate-host-mismatch&lt;/code&gt;, &lt;code&gt;certificate-not-trusted&lt;/code&gt; and, for MTA-STS, &lt;code&gt;sts-policy-fetch-error&lt;/code&gt;, &lt;code&gt;sts-policy-invalid&lt;/code&gt; and &lt;code&gt;sts-webpki-invalid&lt;/code&gt;. It is the same logic as the DMARC reports described in &lt;a href=&quot;/en/changelog/spf-dkim-dmarc&quot;&gt;SPF, DKIM and DMARC&lt;/a&gt;: first observe, then enforce.&lt;/p&gt;
&lt;h2&gt;How to publish it, step by step&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;A valid certificate for &lt;code&gt;mta-sts.example.com&lt;/code&gt;&lt;/strong&gt; and an HTTPS site that serves it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The policy file&lt;/strong&gt;, in &lt;code&gt;mode: testing&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The two DNS records&lt;/strong&gt;: &lt;code&gt;_mta-sts&lt;/code&gt; and &lt;code&gt;_smtp._tls&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;An observation period&lt;/strong&gt; while reading the reports. Google&apos;s instructions for Gmail suggest starting in &lt;code&gt;testing&lt;/code&gt; for about two weeks.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Switch to &lt;code&gt;enforce&lt;/code&gt;&lt;/strong&gt;: edit the file and &lt;strong&gt;change the &lt;code&gt;id&lt;/code&gt;&lt;/strong&gt; in the DNS record, otherwise senders keep using the cached policy until &lt;code&gt;max_age&lt;/code&gt; expires.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;The file can be served by any web server, as long as it answers at that address with the right certificate. The RFC is precise on two details: only an HTTP 200 response is valid, and &lt;strong&gt;3xx redirects are not followed&lt;/strong&gt;. A &lt;code&gt;301&lt;/code&gt; to another address is the same as not having a policy. The expected content type is &lt;code&gt;text/plain&lt;/code&gt;.&lt;/p&gt;
&lt;h2&gt;What can go wrong&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Invalid mail server certificate with &lt;code&gt;enforce&lt;/code&gt; on.&lt;/strong&gt; Senders do not deliver. Exchange Online, for example, returns to the sender a &lt;code&gt;5.7.5&lt;/code&gt; error (&quot;Remote certificate failed MTA-STS validation&quot;) when the destination server&apos;s certificate is not valid. With certificates getting shorter, &lt;a href=&quot;/en/changelog/tls-certificates-47-days&quot;&gt;down to 47 days&lt;/a&gt;, automatic renewal is no longer optional.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;An MX not listed in the policy.&lt;/strong&gt; Exchange Online returns &lt;code&gt;5.4.8&lt;/code&gt; (&quot;MX hosts failed MTA-STS validation&quot;) when the MX host is not the one expected by the policy.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;id&lt;/code&gt; not updated&lt;/strong&gt; after a change: senders use the old policy until &lt;code&gt;max_age&lt;/code&gt; expires.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Wildcards that are too broad&lt;/strong&gt; in the &lt;code&gt;mx&lt;/code&gt; lines: the RFC warns that they weaken the check.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;The limits of MTA-STS&lt;/h2&gt;
&lt;p&gt;RFC 8461 is explicit: MTA-STS protects a domain only if the sender was previously able to obtain and keep the policy. Whoever can block DNS at first contact can stop the sender from learning it and cause the downgrade. The RFC observes that &lt;a href=&quot;/en/changelog/dane-tlsa-smtp-security&quot;&gt;DANE&lt;/a&gt; avoids this problem, because DNSSEC can authoritatively prove that a record does not exist.&lt;/p&gt;
&lt;p&gt;MTA-STS also only protects senders that implement it, and only mail &lt;strong&gt;arriving at&lt;/strong&gt; your domain. For outbound mail, your server must check other people&apos;s policies: for Postfix there is an external component, &lt;code&gt;postfix-mta-sts-resolver&lt;/code&gt;, a daemon that gives Postfix TLS policy based on the recipient domain&apos;s MTA-STS policy.&lt;/p&gt;
&lt;p&gt;Among large providers, Exchange Online validates with MTA-STS all messages sent to MTA-STS-protected recipients, with no configuration needed, and Google documents support in Gmail and Google Workspace (outbound messages to servers with an enforce-mode policy, and a policy you can publish for your own domain).&lt;/p&gt;
&lt;h2&gt;How to verify&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;dig +short TXT _mta-sts.example.com
dig +short TXT _smtp._tls.example.com
curl -sS -i https://mta-sts.example.com/.well-known/mta-sts.txt
openssl s_client -starttls smtp -connect mail.example.com:25 -servername mail.example.com -brief
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The last command shows the certificate presented by the MX: it must be valid and the name must match one of the policy&apos;s &lt;code&gt;mx&lt;/code&gt; lines.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;MTA-STS makes encryption of inbound mail mandatory for whoever asks for it: a DNS record, a file over HTTPS, a valid certificate on the MX servers. You start from &lt;code&gt;testing&lt;/code&gt;, read the TLS-RPT reports and only then move to &lt;code&gt;enforce&lt;/code&gt;. The risk is certificate management; the limit is trust on first connection.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want your domain&apos;s mail to arrive only encrypted?&quot; text=&quot;We set up MTA-STS, TLS-RPT and automatic certificate renewal on the mail servers we manage, with a gradual move to enforce.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc8461.html&quot;&gt;RFC 8461 - SMTP MTA Strict Transport Security (MTA-STS)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc8460.html&quot;&gt;RFC 8460 - SMTP TLS Reporting&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://learn.microsoft.com/en-us/exchange/security-and-compliance/enhance-mail-flow-using-strict-transport-security&quot;&gt;Enhance mail flow with MTA-STS - Microsoft Learn&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://knowledge.workspace.google.com/admin/gmail/advanced/about-mta-sts-and-tls-reporting&quot;&gt;About MTA-STS and TLS reporting - Google Workspace Help&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://knowledge.workspace.google.com/admin/gmail/advanced/create-an-mta-sts-policy&quot;&gt;Create an MTA-STS policy - Google Workspace Help&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/Snawoot/postfix-mta-sts-resolver&quot;&gt;postfix-mta-sts-resolver - GitHub&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>STARTTLS Stripping: Why Email Should Use Implicit TLS</title><link>https://initd.it/en/changelog/starttls-stripping-implicit-tls</link><guid isPermaLink="true">https://initd.it/en/changelog/starttls-stripping-implicit-tls</guid><description>What STARTTLS stripping is, how an attacker downgrades SMTP, IMAP and POP3 to plaintext, and why implicit TLS on ports 465, 993 and 995 is the safer way to encrypt email.</description><pubDate>Sat, 31 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;When you set up a mail account you almost always see a choice like this: &quot;SSL/TLS&quot; or &quot;STARTTLS&quot;. They look like two equivalent ways of encrypting the connection, and in a perfect world they are. In the real world they are not: with STARTTLS the connection &lt;strong&gt;starts in plaintext&lt;/strong&gt; and switches to encryption only after a negotiation, and that negotiation can be sabotaged. The attack is called &lt;strong&gt;STARTTLS stripping&lt;/strong&gt; and it makes passwords and emails travel in the clear without anyone noticing.&lt;/p&gt;
&lt;p&gt;It affects all three mail protocols: &lt;strong&gt;SMTP&lt;/strong&gt; (sending), &lt;strong&gt;IMAP&lt;/strong&gt; and &lt;strong&gt;POP3&lt;/strong&gt; (reading). In this article we look at how the attack works, why &lt;strong&gt;implicit TLS&lt;/strong&gt; (encryption from the very first byte) avoids it by design, and which configuration mistakes, in PHP sites and scripts, turn an &quot;encrypted connection&quot; into one that is encrypted only when things go well.&lt;/p&gt;
&lt;p&gt;A note on names, because they confuse even experienced people. TLS &quot;from the start&quot; is called &lt;strong&gt;implicit&lt;/strong&gt; (&lt;em&gt;implicit TLS&lt;/em&gt;): the port is dedicated to encryption and the first packet is already a TLS handshake. STARTTLS is called &lt;strong&gt;explicit&lt;/strong&gt; TLS: the client connects in plaintext and then asks to upgrade. In mail clients the &quot;SSL/TLS&quot; option almost always means the implicit mode. The word &quot;SSL&quot; is a historical leftover: the old SSL protocols have been dead for years and today you negotiate TLS 1.2 or 1.3.&lt;/p&gt;
&lt;h2&gt;How STARTTLS works (and where it is weak)&lt;/h2&gt;
&lt;p&gt;With STARTTLS the client opens a normal connection, the server states what it can do, and if STARTTLS is among the capabilities the client asks to upgrade. For SMTP, on port 587, it looks like this:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;S: 220 mail.example.com ESMTP
C: EHLO client.example.org
S: 250-mail.example.com
S: 250-STARTTLS
S: 250-AUTH PLAIN LOGIN
S: 250 SIZE 52428800
C: STARTTLS
S: 220 2.0.0 Ready to start TLS
   ... the TLS handshake starts here, everything after is encrypted ...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Everything above the dots travels &lt;strong&gt;in plaintext&lt;/strong&gt;, so an attacker &lt;em&gt;in the middle&lt;/em&gt; (a compromised router, a public Wi-Fi, a network appliance at an ISP) can modify it. Their job is simple: delete the &lt;code&gt;250-STARTTLS&lt;/code&gt; line from the server&apos;s reply, for example by replacing it with meaningless characters of the same length. The client sees a server that cannot encrypt and, if configured permissively, carries on anyway:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;S: 220 mail.example.com ESMTP
C: EHLO client.example.org
S: 250-mail.example.com
S: 250-XXXXXXXA              &amp;lt;- was &quot;250-STARTTLS&quot;, wiped in transit
S: 250-AUTH PLAIN LOGIN
S: 250 SIZE 52428800
C: AUTH PLAIN AHV0ZW50ZQBwYXNzd29yZA==     &amp;lt;- username and password, in the clear
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;That Base64 string is not encryption: one command decodes it, and it contains the username and password. The separator is not &lt;code&gt;:&lt;/code&gt; (that is HTTP Basic): in &lt;code&gt;AUTH PLAIN&lt;/code&gt; (RFC 4616) the fields are separated by a NUL byte, so the decoded string is &lt;code&gt;\0username\0password&lt;/code&gt;. Decoding the string above with &lt;code&gt;echo AHV0ZW50ZQBwYXNzd29yZA== | base64 -d&lt;/code&gt; gives exactly &lt;code&gt;utente&lt;/code&gt; and &lt;code&gt;password&lt;/code&gt; split by two NUL bytes, invisible on screen. The client showed no error, the mail went out, everything seems to work. The attack leaves nothing visible to the user.&lt;/p&gt;
&lt;p&gt;The same trick works on the other protocols. In IMAP the server advertises &lt;code&gt;STARTTLS&lt;/code&gt; among its capabilities, in POP3 the command is called &lt;code&gt;STLS&lt;/code&gt;. It is enough to make the client believe they are missing, or to make the server answer with an error to the command that starts encryption:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;C: STLS
S: -ERR not supported       &amp;lt;- forged by the man in the middle
C: USER mario
C: PASS my-password         &amp;lt;- the permissive client carries on in plaintext
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This is not just theory. The study &lt;em&gt;Neither Snow Nor Rain Nor MITM&lt;/em&gt;, presented in 2015, measured the phenomenon on real traffic and reports evidence of downgrades affecting messages destined for Gmail in several countries.&lt;/p&gt;
&lt;p&gt;RFC 2595, which describes STARTTLS for IMAP and POP3, puts it in writing too: a man-in-the-middle attacker can remove STARTTLS from the server&apos;s capability list.&lt;/p&gt;
&lt;h2&gt;The real problem: clients that do not insist on encryption&lt;/h2&gt;
&lt;p&gt;The crux is this: &lt;strong&gt;STARTTLS is a request, not an obligation&lt;/strong&gt;. If the client is set to use it &quot;when available&quot; (&lt;em&gt;opportunistic TLS&lt;/em&gt;), a server that says &quot;I can&apos;t do it&quot; is accepted. It is the default behaviour of PHPMailer and Symfony Mailer (see below), and it is what the attacker exploits. A site or script that sends mail automatically shows nothing to anyone: if the password goes out in the clear, no error appears.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;PHPMailer&lt;/strong&gt; (used by WordPress and countless back-office tools) has &lt;code&gt;SMTPAutoTLS = true&lt;/code&gt; by default: if &lt;code&gt;SMTPSecure&lt;/code&gt; is empty, it encrypts only when the server says it can, otherwise it carries on in plaintext. The typical snippet &quot;that works&quot; is this:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$mail-&amp;gt;isSMTP();
$mail-&amp;gt;Host     = &apos;mail.example.com&apos;;
$mail-&amp;gt;Port     = 587;
$mail-&amp;gt;SMTPAuth = true;
$mail-&amp;gt;Username = &apos;noreply@example.com&apos;;
$mail-&amp;gt;Password = $password;
// SMTPSecure not set: opportunistic encryption, strippable
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;Symfony Mailer&lt;/strong&gt; behaves the same way with the &lt;code&gt;smtp://&lt;/code&gt; scheme: the documentation says it uses encryption when the OpenSSL extension is enabled and the server supports STARTTLS, and in the code the automatic mode (&lt;code&gt;auto_tls&lt;/code&gt;) is on by default. If the server does not advertise it, the mail goes out in plaintext. &lt;strong&gt;Laravel&lt;/strong&gt; is built on Symfony Mailer: in version 12&apos;s &lt;code&gt;MailManager&lt;/code&gt; the scheme is the one set in &lt;code&gt;scheme&lt;/code&gt; (the &lt;code&gt;MAIL_SCHEME&lt;/code&gt; variable) and, if it is missing, it is &lt;code&gt;smtps&lt;/code&gt; on port 465 and &lt;code&gt;smtp&lt;/code&gt; on any other port. A typical &lt;code&gt;.env&lt;/code&gt; configuration is therefore:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;MAIL_MAILER=smtp
MAIL_HOST=mail.example.com
MAIL_PORT=587           # smtp scheme: opportunistic STARTTLS
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In &lt;strong&gt;Python&lt;/strong&gt; too, certificate verification is not automatic: in the CPython source, if you do not pass an SSL context to &lt;code&gt;smtplib.SMTP.starttls()&lt;/code&gt;, &lt;code&gt;smtplib.SMTP_SSL&lt;/code&gt; or &lt;code&gt;imaplib.IMAP4_SSL&lt;/code&gt;, one is created that verifies neither the certificate nor the hostname (&lt;code&gt;ssl._create_stdlib_context&lt;/code&gt; is an alias of &lt;code&gt;_create_unverified_context&lt;/code&gt;). Another classic mistake is turning off verification to &quot;make it work&quot; with a server whose certificate is expired or self-signed (&lt;code&gt;/novalidate-cert&lt;/code&gt; in PHP IMAP, which validates certificates by default; &lt;code&gt;verify_peer=0&lt;/code&gt; in Symfony; &lt;code&gt;SMTPOptions&lt;/code&gt; with &lt;code&gt;verify_peer =&amp;gt; false&lt;/code&gt; in PHPMailer). At that point encryption is there, but whoever sits in the middle can present any certificate they like: the connection is encrypted towards the attacker.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do your sites and scripts send mail with passwords in transit?&quot; text=&quot;We check how they connect to the mail server, whether encryption is really mandatory and whether certificates are verified.&quot; button=&quot;Request a check →&quot;}&lt;/p&gt;
&lt;h2&gt;Why implicit TLS is better&lt;/h2&gt;
&lt;p&gt;With implicit TLS the client connects to a dedicated port (465 for sending, 993 for IMAP, 995 for POP3) and &lt;strong&gt;the very first thing it exchanges is the TLS handshake&lt;/strong&gt;. There is no plaintext phase to tamper with and no &lt;code&gt;STARTTLS&lt;/code&gt; capability to delete: if TLS does not start, the connection drops and that is it. The client cannot &quot;slip&quot; into plaintext even if it wanted to.&lt;/p&gt;
&lt;p&gt;There are other advantages that matter in practice:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Less complexity, fewer bugs.&lt;/strong&gt; STARTTLS requires handling the switch from plaintext to encrypted within the same data stream. A whole family of vulnerabilities was born here: the STARTTLS &lt;em&gt;command injection&lt;/em&gt; (for example CVE-2011-0411 in Postfix) made the server process, as if it were inside the encrypted session, a command sent in plaintext. RFC 8314 cites it (CERT VU#555316) and notes that the error was made independently by multiple implementers, which suggests a less secure architecture than implicit TLS. In 2021 the study &lt;em&gt;Why TLS is better without STARTTLS&lt;/em&gt; (USENIX Security) found more than 40 vulnerabilities in STARTTLS implementations and about 320,000 vulnerable mail servers.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;It is what the standard recommends.&lt;/strong&gt; RFC 8314 (2018) names implicit TLS as the preferred way to submit and read mail, asks servers to offer it and to phase out cleartext as soon as practicable, and asks clients not to send credentials unless the session is properly encrypted and to validate the certificate.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Port 465 is official again.&lt;/strong&gt; Historically it had been registered as &quot;smtps&quot;, then the registration was revoked; RFC 8314 assigned it again, under the name &lt;code&gt;submissions&lt;/code&gt;, to mail submission over TLS.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The RFC is honest on one point: if &lt;strong&gt;both sides are implemented correctly&lt;/strong&gt; and the client &lt;em&gt;insists&lt;/em&gt; on encryption, there is no significant difference between STARTTLS on 587 and implicit TLS on 465. The problem is that &quot;if implemented correctly&quot; is a fragile condition, and implicit TLS does not need it.&lt;/p&gt;
&lt;h2&gt;How to configure it properly, client side&lt;/h2&gt;
&lt;p&gt;The rule is the same in every language: &lt;strong&gt;implicit TLS port, verified certificate, no fallback&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;PHPMailer, SMTP on 465:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$mail-&amp;gt;isSMTP();
$mail-&amp;gt;Host        = &apos;mail.example.com&apos;;
$mail-&amp;gt;Port        = 465;
$mail-&amp;gt;SMTPSecure  = PHPMailer::ENCRYPTION_SMTPS;   // implicit TLS
$mail-&amp;gt;SMTPAutoTLS = false;
$mail-&amp;gt;SMTPAuth    = true;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Laravel 12, &lt;code&gt;smtps&lt;/code&gt; scheme (implicit TLS) instead of &lt;code&gt;smtp&lt;/code&gt;. On port 465 it picks it by itself, but it is better to write it explicitly:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;MAIL_MAILER=smtp
MAIL_HOST=mail.example.com
MAIL_PORT=465
MAIL_SCHEME=smtps
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;If for some reason you have to stay on STARTTLS (587), with Symfony Mailer you should at least enforce &lt;code&gt;require_tls&lt;/code&gt;: if the server does not offer encryption, sending fails with an exception instead of going out in plaintext.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;smtp://user:password@mail.example.com:587?require_tls=true
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Python, IMAP and SMTP with a context that verifies certificate and hostname (&lt;code&gt;ssl.create_default_context()&lt;/code&gt; sets &lt;code&gt;CERT_REQUIRED&lt;/code&gt; and &lt;code&gt;check_hostname&lt;/code&gt;):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import imaplib, smtplib, ssl

ctx = ssl.create_default_context()   # verifies chain and hostname

imap = imaplib.IMAP4_SSL(&quot;mail.example.com&quot;, 993, ssl_context=ctx)
smtp = smtplib.SMTP_SSL(&quot;mail.example.com&quot;, 465, context=ctx)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;With PHP IMAP the &lt;code&gt;/ssl&lt;/code&gt; flag uses TLS from the start, while &lt;code&gt;/tls&lt;/code&gt; forces STARTTLS and rejects servers that do not support it; certificate validation is on by default and &lt;code&gt;/novalidate-cert&lt;/code&gt; turns it off. For mail programs the rule is the same: pick the &quot;SSL/TLS&quot; option with ports 993, 995 and 465.&lt;/p&gt;
&lt;h2&gt;How to configure it properly, server side&lt;/h2&gt;
&lt;p&gt;The server must stop accepting plaintext, otherwise any misconfigured client stays vulnerable. Postfix, &lt;code&gt;submissions&lt;/code&gt; service in &lt;code&gt;master.cf&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;submissions inet n - n - - smtpd
  -o smtpd_tls_wrappermode=yes
  -o smtpd_sasl_auth_enable=yes
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This is the example from the Postfix documentation: in &lt;em&gt;wrapper mode&lt;/em&gt; the server always uses TLS instead of offering STARTTLS. If you also keep 587, the documentation describes &lt;code&gt;smtpd_tls_security_level = encrypt&lt;/code&gt; (the server announces STARTTLS and accepts no mail without encryption; the documentation advises against it for a public MX server, so use it only on the submission service) and &lt;code&gt;smtpd_tls_auth_only = yes&lt;/code&gt; (authentication is offered only after STARTTLS). In Dovecot, &lt;code&gt;ssl = required&lt;/code&gt; makes any authentication attempt fail before TLS is on, and you can leave only the implicit TLS ports enabled, because &lt;code&gt;port = 0&lt;/code&gt; disables a listener:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;ssl = required

service imap-login {
  inet_listener imap  { port = 0 }                # plain IMAP/STARTTLS off
  inet_listener imaps { port = 993 ssl = yes }
}
service pop3-login {
  inet_listener pop3  { port = 0 }
  inet_listener pop3s { port = 995 ssl = yes }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Turning off ports 143 and 110 can break old clients: before doing it, read the logs to see who still uses them and update their settings.&lt;/p&gt;
&lt;h2&gt;Port 25 is a different story&lt;/h2&gt;
&lt;p&gt;All of this concerns mail that a user or application sends to &lt;strong&gt;their own&lt;/strong&gt; server or reads from their own server. Between different mail servers (port 25) implicit TLS is not practical: RFC 8314 observes that the MX infrastructure has no way to specify a different port. Encryption therefore stays opportunistic, and RFC 7672 recalls that the server&apos;s indication of TLS support can easily be suppressed by a man-in-the-middle attacker. The &lt;em&gt;stripping&lt;/em&gt; risk remains here, and there are dedicated countermeasures: &lt;a href=&quot;/en/changelog/mta-sts-enforce-email-encryption&quot;&gt;&lt;strong&gt;MTA-STS&lt;/strong&gt;&lt;/a&gt; (RFC 8461) and &lt;a href=&quot;/en/changelog/dane-tlsa-smtp-security&quot;&gt;&lt;strong&gt;DANE&lt;/strong&gt;&lt;/a&gt; (RFC 7672) let the receiving domain declare &quot;you reach me only encrypted&quot;. They are the natural complement to &lt;a href=&quot;/en/changelog/spf-dkim-dmarc&quot;&gt;SPF, DKIM and DMARC&lt;/a&gt;: those authenticate the sender, these protect the path.&lt;/p&gt;
&lt;h2&gt;How to check that your server holds up&lt;/h2&gt;
&lt;p&gt;With &lt;code&gt;openssl&lt;/code&gt; you can see what a server offers in a few seconds. A check on the implicit mode:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;openssl s_client -connect mail.example.com:465 -brief
openssl s_client -connect mail.example.com:993 -brief
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;And on the STARTTLS mode, to see what the server announces (&lt;code&gt;-starttls&lt;/code&gt; accepts &lt;code&gt;smtp&lt;/code&gt;, &lt;code&gt;pop3&lt;/code&gt; and &lt;code&gt;imap&lt;/code&gt;):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;openssl s_client -starttls smtp -connect mail.example.com:587 -crlf
openssl s_client -starttls imap -connect mail.example.com:143
printf &apos;a CAPABILITY\r\n&apos; | nc mail.example.com 143
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The last command queries port 143 without TLS. RFC 2595 allows an IMAP server to advertise &lt;code&gt;LOGINDISABLED&lt;/code&gt;, meaning plaintext &lt;code&gt;LOGIN&lt;/code&gt; is off; the same RFC warns that this only protects against passive eavesdropping, because an active attacker can remove the announcement. The test that matters is trying an authentication &lt;strong&gt;before&lt;/strong&gt; STARTTLS: a properly configured server refuses it (with Dovecot, &lt;code&gt;ssl = required&lt;/code&gt; makes authentication fail before TLS). If it accepts, a badly configured client can send it credentials in the clear, and an attacker can force it to. If you also manage &lt;a href=&quot;/en/changelog/tls-certificates-47-days&quot;&gt;TLS certificates heading to 47 days&lt;/a&gt; you have another reason to check: an expired certificate on the mail server is the most common excuse for disabling verification on the client.&lt;/p&gt;
&lt;h2&gt;The most frequent mistakes, in short&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&quot;It works, so it is encrypted.&quot;&lt;/strong&gt; Not true: opportunistic STARTTLS works in plaintext too, and the mail still arrives.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Certificate verification disabled&lt;/strong&gt; because the certificate is expired or self-signed. You fix the certificate, not the verification.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Reused credentials&lt;/strong&gt; across mail, control panel and other services: if they went through in plaintext once, they must be changed. A leaked password is ideal material for &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;brute force attacks&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Ports 143/110 left open &quot;just in case&quot;&lt;/strong&gt;, with plaintext still allowed.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;No monitoring&lt;/strong&gt;: an application sending in plaintext because of a configuration error raises no alarm. RFC 8314 recommends that servers record the negotiated cipher suite in the &lt;code&gt;Received&lt;/code&gt; header and in connection and authentication logs: checking them periodically shows who connects without TLS.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;STARTTLS stripping is not a sophisticated attack: it is enough to delete one line from a conversation that starts in plaintext. It works because many clients, including PHPMailer, Symfony Mailer and many script libraries, treat encryption as an option to use &quot;if it is there&quot;. Implicit TLS on ports 465, 993 and 995 removes the problem at the root: either the connection is encrypted or it does not exist. When you cannot give up STARTTLS, you must at least enforce it (&lt;code&gt;require_tls&lt;/code&gt;, &lt;code&gt;smtpd_tls_auth_only&lt;/code&gt;, &lt;code&gt;ssl = required&lt;/code&gt;) and verify the certificate. And on the path between servers, where implicit TLS does not exist, you need &lt;a href=&quot;/en/changelog/mta-sts-enforce-email-encryption&quot;&gt;MTA-STS&lt;/a&gt; or &lt;a href=&quot;/en/changelog/dane-tlsa-smtp-security&quot;&gt;DANE&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to know whether your mail really travels encrypted?&quot; text=&quot;We audit servers and applications, move SMTP, IMAP and POP3 to implicit TLS and enforce encryption server side, with documented tests before and after.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc8314.html&quot;&gt;RFC 8314 - Cleartext Considered Obsolete: Use of TLS for Email Submission and Access&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc3207.html&quot;&gt;RFC 3207 - SMTP Service Extension for Secure SMTP over TLS&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc4616.html&quot;&gt;RFC 4616 - The PLAIN Simple Authentication and Security Layer (SASL) Mechanism&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://nvd.nist.gov/vuln/detail/CVE-2011-0411&quot;&gt;CVE-2011-0411 - Postfix STARTTLS&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://doc.dovecot.org/main/core/config/ssl.html&quot;&gt;Dovecot documentation - SSL&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.postfix.org/TLS_README.html&quot;&gt;Postfix documentation - TLS_README&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/manual/en/function.imap-open.php&quot;&gt;PHP documentation - imap_open&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc2595.html&quot;&gt;RFC 2595 - Using TLS with IMAP, POP3 and ACAP&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc8461.html&quot;&gt;RFC 8461 - SMTP MTA Strict Transport Security (MTA-STS)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc7672.html&quot;&gt;RFC 7672 - SMTP Security via Opportunistic DANE TLS&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://nostarttls.secvuln.info/&quot;&gt;Why TLS is better without STARTTLS (USENIX Security 2021)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://research.google/pubs/neither-snow-nor-rain-nor-mitm-an-empirical-analysis-of-email-delivery-security/&quot;&gt;Neither Snow Nor Rain Nor MITM: An Empirical Analysis of Email Delivery Security (IMC 2015)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://symfony.com/doc/current/mailer.html&quot;&gt;Symfony Mailer - Transport Setup&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/PHPMailer/PHPMailer/blob/master/src/PHPMailer.php&quot;&gt;PHPMailer - SMTPSecure and SMTPAutoTLS properties&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Hacked PrestaShop: checkout skimmers, fake admins and how to spot them</title><link>https://initd.it/en/changelog/hacked-prestashop-skimmer</link><guid isPermaLink="true">https://initd.it/en/changelog/hacked-prestashop-skimmer</guid><description>How to recognise a hacked PrestaShop store: skimmers copying cards in the checkout, fake admins, suspicious files. What to do right away, what not to do and how to close the hole.</description><pubDate>Fri, 23 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;A hacked brochure site usually gets noticed: redirects to spam sites, the browser&apos;s red warning, Google flagging it. A hacked PrestaShop store often doesn&apos;t. The most profitable attack on an online store doesn&apos;t want to be seen: it wants to stay hidden in the checkout as long as possible, copying customers&apos; card details while the store keeps selling as usual.&lt;/p&gt;
&lt;p&gt;In this article we look at how these attacks work, which signs give them away, what to do in the first hours and how to stop them from happening again.&lt;/p&gt;
&lt;h2&gt;How an attack gets into a PrestaShop store&lt;/h2&gt;
&lt;p&gt;The ways in are almost always the same:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;modules with known vulnerabilities&lt;/strong&gt; never updated, especially those receiving external data (imports, forms, search);&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;old PrestaShop versions&lt;/strong&gt;, missing years of fixes, as we saw when discussing &lt;a href=&quot;/en/changelog/prestashop-1-7-8-risks&quot;&gt;stores staying on PrestaShop 1.7 or 8&lt;/a&gt;;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;back office passwords&lt;/strong&gt; that are weak or reused, attacked by trial and error;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;an admin area&lt;/strong&gt; reachable at an easy-to-guess address.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A real case: in July 2022 PrestaShop warned merchants of a campaign exploiting an &lt;em&gt;SQL injection&lt;/em&gt;, a way to make the database run unintended commands, present in old versions and in a widespread module. The attackers created a file in the site root, took control of the server and added a &lt;strong&gt;fake payment module&lt;/strong&gt; to the checkout that sent card details to them.&lt;/p&gt;
&lt;h2&gt;What a skimmer is and where it hides&lt;/h2&gt;
&lt;p&gt;A &lt;strong&gt;skimmer&lt;/strong&gt; is a small script that reads what the customer types in the card fields and sends it to an external server. The name comes from devices secretly fitted to cash machines. In a PrestaShop store it can sit:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;in a &lt;strong&gt;theme or module file&lt;/strong&gt;, modified by adding a few lines;&lt;/li&gt;
&lt;li&gt;in the &lt;strong&gt;database&lt;/strong&gt;, inside a setting or a content block printed on the payment page;&lt;/li&gt;
&lt;li&gt;in a &lt;strong&gt;fake payment module&lt;/strong&gt;, posing as an extra method or replacing the real one.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;It often activates only on the payment page, only for some visitors or only on mobile, precisely to avoid being noticed by whoever runs the store.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Worried your checkout may be compromised?&quot; text=&quot;We check files, database and payment modules, find how they got in and close the hole. A quote before we start, and a report including the dates your payment provider will need.&quot; button=&quot;Request a check →&quot;}&lt;/p&gt;
&lt;h2&gt;Signs not to ignore&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Customers reporting odd charges&lt;/strong&gt; after a purchase: often the first sign, and it comes late.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The checkout looks different&lt;/strong&gt;: an extra field, a new step, a payment method nobody configured.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Unknown admins&lt;/strong&gt; in the back office, or logins from countries where nobody works.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;New PHP files&lt;/strong&gt; in folders that shouldn&apos;t contain any, such as image or cache folders.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Sudden slowdowns&lt;/strong&gt; with no obvious reason: they can have &lt;a href=&quot;/en/changelog/speed-up-prestashop&quot;&gt;plenty of innocent causes&lt;/a&gt;, but also foreign code running on every page.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;External warnings&lt;/strong&gt;: Google Search Console, the payment provider, the host reporting unusual traffic.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;The first hours: what to do and what not to do&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Do&lt;/strong&gt;: back up the current state before touching anything, because it helps understand what happened and since when; change every password, back office, database, hosting, FTP; tell your payment provider if you suspect card details were read.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Don&apos;t&lt;/strong&gt;: hastily restore an old backup without finding the hole, because the attacker comes back through the same door within days; delete files at random, losing the traces; wait &quot;to see if it happens again&quot;. If personal data is involved, GDPR requires notifying the authority within 72 hours of becoming aware of the breach, even if the picture isn&apos;t complete yet (the notification can be supplemented later), and in many cases telling customers too: we covered this in &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR on the infrastructure side&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;Close the door, don&apos;t just clean up&lt;/h2&gt;
&lt;p&gt;Removing the skimmer is half the job: it&apos;s what we do in &lt;a href=&quot;/en/fixes/prestashop-malware-removal&quot;&gt;PrestaShop malware removal&lt;/a&gt;, together with finding the entry point. The other half is finding how it got in and closing that path: updating or replacing the vulnerable module, updating PrestaShop, moving and protecting the admin area, limiting login attempts as you would with &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;fail2ban against brute force attacks&lt;/a&gt;. And having &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;backups that actually restore&lt;/a&gt;, clean and stored elsewhere, so you don&apos;t have to choose between an infected store and one months out of date.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;A hacked PrestaShop store isn&apos;t always visible: the most common attack on an online store targets the checkout and stays hidden. The signs are there, from charges reported by customers to unknown admins. When it happens, you need a backup of the current state, new passwords, a cleanup of files and database and, above all, closing the hole it came through. Regular updates and a protected back office do the rest.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to secure your PrestaShop store?&quot; text=&quot;We clean compromised stores, close the hole when an update or a configuration change is enough, and keep core and modules updated with monthly maintenance.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://build.prestashop-project.org/news/2022/major-security-vulnerability-on-prestashop-websites/&quot;&gt;Major security vulnerability on PrestaShop websites&lt;/a&gt; - PrestaShop Project, July 2022&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32016R0679&quot;&gt;Regulation (EU) 2016/679, Article 33&lt;/a&gt; - notification of a personal data breach&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://devdocs.prestashop-project.org/9/project/security-policy/&quot;&gt;Security policy - PrestaShop 9&lt;/a&gt; - official documentation&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Critical PHP Vulnerability (PHP2Shell): What to Do Today to Protect Your Sites</title><link>https://initd.it/en/changelog/php2shell-critical-php-vulnerabilities</link><guid isPermaLink="true">https://initd.it/en/changelog/php2shell-critical-php-vulnerabilities</guid><description>PHP2Shell: two critical flaws (CVE-2026-109618 and CVE-2026-109619) allow code execution on the server with no password. Fixed versions, temporary mitigations and how to verify.</description><pubDate>Wed, 21 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;On 21 October 2026 the PHP security team released emergency updates for two &lt;strong&gt;critical&lt;/strong&gt; vulnerabilities, rated &lt;strong&gt;9.2 out of 10&lt;/strong&gt;: CVE-2026-109618 and CVE-2026-109619, nicknamed &lt;strong&gt;PHP2Shell&lt;/strong&gt;. According to the official advisory they can let anyone, &lt;strong&gt;with no password and no account&lt;/strong&gt;, run commands on the server that runs PHP. They are not flaws in WordPress, PrestaShop or some plugin: they sit in the &lt;strong&gt;interpreter&lt;/strong&gt;, the program that executes PHP code, so they affect any site or business application running on top of it.&lt;/p&gt;
&lt;p&gt;If you run a site, an online shop or a management application written in PHP, there are three things to do today: find out which version it runs on, update it, and check that the update really landed. The UK National Cyber Security Centre (NCSC) has urged organisations to act immediately and, for systems that cannot be fixed, to consider taking them offline for now.&lt;/p&gt;
&lt;p&gt;Below: what is happening, who is exposed, what to do and in which order, how to reduce the risk if you cannot update today, and how to tell whether someone is already inside. The information comes from the PHP project&apos;s advisory, the two advisories published on GitHub, the report by Wiz Research, which found the flaws, and the NCSC, all linked at the bottom. Things are moving fast: this text is a snapshot of 18:00 CEST (16:00 UTC) on 21 October.&lt;/p&gt;
&lt;h2&gt;What was found: two flaws in how PHP handles out-of-memory errors&lt;/h2&gt;
&lt;p&gt;Both stem from what happens when a web request dies badly, in particular when PHP runs out of the memory it was allowed while it is still setting the request up.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;CVE-2026-109618, memory corruption on memory exhaustion&lt;/strong&gt;: if memory runs out at the wrong moment, PHP aborts the request with an emergency exit and leaves some internal data half-built. The end-of-request cleanup treats it as if it were in order and works on it. It is like a warehouse worker who finds an order only half packed, closes it as complete and starts touching shelves that do not exist.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;CVE-2026-109619, leftover state between one request and the next&lt;/strong&gt;: a PHP &lt;strong&gt;worker&lt;/strong&gt;, the process that serves requests and is reused for thousands of visitors, can keep references to memory from the previous request that has already been freed. The next request uses them before they are reset. It is a whiteboard the previous customer did not wipe, which the next one reads and writes thinking it is blank.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;With the right sequence of requests an attacker can read parts of the server&apos;s memory and end up &lt;strong&gt;running code with the web server&apos;s privileges&lt;/strong&gt;. The attack goes in particular through &lt;em&gt;multipart&lt;/em&gt; HTTP requests (the kind used by forms with file uploads), needs no login and does not depend on the application: Wiz demonstrated unauthenticated code execution against the latest WordPress, Drupal and Joomla images, and the PHP project reports a full demonstration against Apache with mod_php and default settings.&lt;/p&gt;
&lt;p&gt;A note on tone: the official score lists the attack complexity as high and, according to Wiz, full code execution requires chaining several defects and adapting to the target&apos;s memory layout. It is not within everyone&apos;s reach, but the demonstration exists, and Wiz, which says it used AI models in its research, argues that this very adaptation work is what AI makes cheaper.&lt;/p&gt;
&lt;p&gt;The timeline: reported to the PHP team on 24 August, acknowledged on 21 September, on 20 October the identifiers of the flaws leaked online and PHP announced an emergency release, and the fixes shipped on 21 October.&lt;/p&gt;
&lt;h2&gt;Who is exposed and which versions are fixed&lt;/h2&gt;
&lt;p&gt;The versions that fix both flaws are &lt;strong&gt;PHP 8.5.12, 8.4.27, 8.3.36 and 8.2.35&lt;/strong&gt;. The project lists installations that serve web requests as at risk: PHP-FPM, Apache with mod_php, php-cgi, FrankenPHP and LiteSpeed, with the highest risk for mod_php. Command-line scripts alone are not the case described, but they get updated along with everything else.&lt;/p&gt;
&lt;p&gt;Old versions are the sore point. PHP 8.1 and earlier no longer get updates from the project, and Wiz estimates that every version back to 5.4 is hit by at least one of the two flaws. For PHP 7.4, 8.0 and 8.1 minimal source-code fixes were published, useful to those who build PHP themselves; Linux distributions and extended-support (LTS) vendors received the patches in advance. It is the scenario we describe in &lt;a href=&quot;/en/changelog/php-end-of-life-risks&quot;&gt;PHP end of life&lt;/a&gt;: on an abandoned version every new flaw stays open, unless someone fixes it for you. If that someone is the Linux distribution, the open question is whether it &lt;a href=&quot;/en/changelog/php-backported-patches-nis2-supported&quot;&gt;counts as supported software under NIS2&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;It is not only about the website. PHP also runs inside control panels, management software, appliances and products that bundle it: the NCSC asks you to inventory these too and to follow vendors&apos; updates. On shared hosting the provider does the update, and it makes sense to ask them for written confirmation rather than assume.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Not sure which PHP your sites run on, or whether the fix is really applied?&quot; text=&quot;We check it for you: we inventory PHP versions and how it is run across servers, hosting and containers, confirm the patch is active and look for traces of unusual access. We tell you what is fine and what to do first.&quot; button=&quot;Ask for the analysis →&quot;}&lt;/p&gt;
&lt;h2&gt;What to do now: update, restart, verify&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Inventory&lt;/strong&gt;: list where PHP runs (servers, hosting, containers, panels, software that bundles PHP) and start with whatever is reachable from the internet. Do not limit yourself to old systems: the NCSC asks for that too.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Backup&lt;/strong&gt;: before touching anything, &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;a verified copy&lt;/a&gt;. These are maintenance updates and the risk of breakage is low, but the rule always applies.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Update&lt;/strong&gt;: on a server using the distribution&apos;s PHP packages, then restart the services, because workers that are already running keep the old code in memory:&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;sudo apt update &amp;amp;&amp;amp; sudo apt upgrade
sudo systemctl restart php8.3-fpm
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The service name depends on the version (&lt;code&gt;php8.4-fpm&lt;/code&gt;, &lt;code&gt;php8.2-fpm&lt;/code&gt;); with Apache and mod_php you restart &lt;code&gt;apache2&lt;/code&gt;. On Red Hat family distributions the command is &lt;code&gt;dnf upgrade&lt;/code&gt;, but anyone using the third-party Remi repository should know that &lt;s&gt;on 21 October it had no updated packages yet: the suggested route is to switch to the distribution&apos;s packages or build from source&lt;/s&gt;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Update, 6 November 2026:&lt;/strong&gt; Remi&apos;s packages for PHP 7.4, 8.0 and 8.1 carry a changelog entry dated 21 October 2026, &quot;Mitigation fix&quot;, listing both CVEs, so the fix exists. The struck-out sentence, written at 18:00 CEST that day, no longer holds; we do not know whether the packages were already published at that hour. We leave it visible for transparency.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Real verification&lt;/strong&gt;: the number shown by &lt;code&gt;php -v&lt;/code&gt; is not enough on its own. Debian published the fix under the new number (on Debian 12 the fixed package is &lt;code&gt;8.2.35-1~deb12u1&lt;/code&gt;), while Ubuntu &lt;em&gt;backported&lt;/em&gt; it onto the version it already shipped: on Ubuntu 24.04 the fix is in package &lt;code&gt;8.3.6-0ubuntu0.24.04.13&lt;/code&gt;, so &lt;code&gt;php -v&lt;/code&gt; shows 8.3.6, a number that looks older than the fixed 8.3.36, and yet the system is fine. In both cases what works is the changelog of the installed package, which cites the CVEs (the same method applies to &lt;a href=&quot;/en/changelog/cve-2026-98432-linux-kernel-tcp-what-to-do&quot;&gt;the Linux kernel flaw CVE-2026-98432&lt;/a&gt;, though there the CVE number does not appear in every changelog):&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;zcat /usr/share/doc/php8.3-fpm/changelog.Debian.gz | grep -m2 &apos;CVE-2026-10961[89]&apos;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;For the official &lt;code&gt;php:&lt;/code&gt; Docker images and for installations built from source the opposite holds: the version number is the real one and must be at least one of the fixed ones. For containers, rebuild with &lt;code&gt;docker build --pull&lt;/code&gt; and check the version &lt;em&gt;inside&lt;/em&gt; the image with &lt;code&gt;docker run --rm &amp;lt;image&amp;gt; php -v&lt;/code&gt;.&lt;/p&gt;
&lt;h2&gt;If you cannot update today: temporary mitigations (and their limits)&lt;/h2&gt;
&lt;p&gt;The PHP project is blunt: these measures &lt;strong&gt;do not make an installation safe&lt;/strong&gt;. They reduce the attack surface, they do not fix anything, and they buy you a few hours. In the PHP-FPM pool (on Debian and Ubuntu, &lt;code&gt;/etc/php/8.3/fpm/pool.d/www.conf&lt;/code&gt;):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;php_admin_value[memory_limit] = -1
php_admin_value[post_max_size] = 8M
php_admin_value[session.upload_progress.enabled] = 0
; PHP 8.5 only
php_admin_value[fatal_error_backtraces] = 0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;After the change, restart all workers. What each line does:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;memory_limit = -1&lt;/code&gt;&lt;/strong&gt; looks absurd, but the first flaw is triggered precisely when PHP hits its memory limit. The price is that a runaway script can eat all the RAM: the ceiling must be set upstream, with container or cgroup limits, and not with &lt;code&gt;RLIMIT_AS&lt;/code&gt; or &lt;code&gt;RLIMIT_DATA&lt;/code&gt;, which cause the very error you are trying to avoid. It is set with &lt;code&gt;php_admin_value&lt;/code&gt;, which applications cannot override, checking that no pool or directory puts a limit back.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;post_max_size = 8M&lt;/code&gt;&lt;/strong&gt; caps the size of requests (32M if you need file uploads, keeping &lt;code&gt;upload_max_filesize&lt;/code&gt; lower). With 8M every bigger upload stops working.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;session.upload_progress.enabled = 0&lt;/code&gt;&lt;/strong&gt; turns off the upload progress bar, the feature used by the second flaw. It must be set in the server or pool configuration, not with &lt;code&gt;ini_set()&lt;/code&gt; or &lt;code&gt;.user.ini&lt;/code&gt;, which arrive too late. The project recommends keeping it off after the update too, if you do not need it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;fatal_error_backtraces = 0&lt;/code&gt;&lt;/strong&gt; closes only one of the known paths, and exists only from PHP 8.5.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;In front of the application, a &lt;a href=&quot;/en/changelog/nginx-reverse-proxy&quot;&gt;reverse proxy&lt;/a&gt; can enforce limits on request size and, for sites with no upload forms, block multipart requests altogether. Cloudflare has switched on WAF rules for the known vectors, even on free plans: they only help if the server accepts traffic exclusively from Cloudflare, and Patchstack considers them a stopgap. If none of these measures is practical and the system is exposed, the NCSC suggests taking it offline until it is updated.&lt;/p&gt;
&lt;h2&gt;How to tell whether someone is already inside&lt;/h2&gt;
&lt;p&gt;Updating closes the door but does not throw out whoever is already in. The flaws act below the application layer, so the site&apos;s logs may show almost nothing. The signs pointed out by Wiz and Huntress:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;unusual multipart requests followed by out-of-memory errors or runs of HTTP 500 responses;&lt;/li&gt;
&lt;li&gt;anomalous &lt;code&gt;PHPSESSID&lt;/code&gt; cookies, very large or malformed, in responses;&lt;/li&gt;
&lt;li&gt;unexplained restarts of PHP workers;&lt;/li&gt;
&lt;li&gt;web server processes (&lt;code&gt;php-fpm&lt;/code&gt;, &lt;code&gt;apache2&lt;/code&gt;, &lt;code&gt;httpd&lt;/code&gt;) launching shells, download tools such as &lt;code&gt;curl&lt;/code&gt; or &lt;code&gt;wget&lt;/code&gt;, or reconnaissance commands such as &lt;code&gt;whoami&lt;/code&gt;, &lt;code&gt;id&lt;/code&gt;, &lt;code&gt;uname -a&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;On disk, look for new or modified PHP files and scheduled tasks nobody created:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;find /var/www -name &apos;*.php&apos; -mtime -3 -ls
crontab -l -u www-data
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The web server user is &lt;code&gt;www-data&lt;/code&gt; on Debian and Ubuntu, &lt;code&gt;apache&lt;/code&gt; or &lt;code&gt;nginx&lt;/code&gt; elsewhere. If you find something: isolate the server, keep the logs and do not just clean up. One of the flaws allows reading worker memory, so on a compromised server, or even a suspected one, the secrets the application held in memory should be treated as exposed: database passwords, API keys, session and encryption keys. Wiz advises considering rotating them. If the server handles personal data and there is a risk to individuals, the breach must be notified to the data protection authority without undue delay and, where feasible, within 72 hours: we cover it in &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR from the infrastructure side&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;Is it already being exploited? The sources disagree&lt;/h2&gt;
&lt;p&gt;At 14:00 UTC on 21 October Huntress stated it had not observed exploitation among its partners and knew of no public attack code (a short demonstration video had been posted and then removed). In the same hours Patchstack was receiving incident reports from hosting partners, but its own telemetry showed only probing attempts; Cloudflare&apos;s CTO spoke of early attacks and watchTowr claimed attempts against its own honeypots. None of these sources is conclusive on its own.&lt;/p&gt;
&lt;p&gt;The prudent reading is to treat exploitation as imminent: with the details public and a working demonstration out there, the window before mass automated attacks is measured in hours or a few days.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Two critical flaws in the core of PHP, CVE-2026-109618 and CVE-2026-109619, allow, according to the project, running code on the server without authentication. They are fixed in PHP 8.5.12, 8.4.27, 8.3.36 and 8.2.35, and by distributions in their own packages. You inventory, update, restart the workers and check the changelog rather than the version number. Where that is not possible, temporary mitigations reduce the attack surface but fix nothing, and an end-of-life PHP should be taken off the internet or migrated. After updating, look for traces of access and, when in doubt, change the secrets.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want us to check your PHP servers before someone else does?&quot; text=&quot;We run a targeted analysis: an inventory of where PHP runs, confirmation that the fix is really active, mitigations where updating is not possible, a search for signs of compromise and, if needed, secret rotation. We run Linux servers and PHP applications for SMEs, firms and agencies.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/archive/2026.php#2026-10-21-5&quot;&gt;PHP.net, security advisory &quot;Critical remote code execution vulnerabilities, update now&quot; (21 October 2026)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-w8hw-w9fx-j79w&quot;&gt;PHP, advisory GHSA-w8hw-w9fx-j79w for CVE-2026-109618&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp&quot;&gt;PHP, advisory GHSA-6wmf-4rv5-p3rp for CVE-2026-109619&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.wiz.io/blog/php2shell-php-rce&quot;&gt;Wiz Research, PHP2Shell: technical report on the discovery&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.ncsc.gov.uk/news/critical-security-issue-affecting-php&quot;&gt;NCSC, &quot;Critical security issue affecting PHP&quot; (21 October 2026)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://patchstack.com/articles/php-major-vulnerability-alert-10-2026/&quot;&gt;Patchstack, advisory and live updates on the PHP vulnerability&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.huntress.com/blog/php2shell-leaked-critical-php-vulnerabilities&quot;&gt;Huntress, Rapid Response: php2shell&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://ubuntu.com/security/CVE-2026-109618&quot;&gt;Ubuntu, fixed packages for CVE-2026-109618&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://security-tracker.debian.org/tracker/CVE-2026-109618&quot;&gt;Debian Security Tracker, CVE-2026-109618&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>PrestaShop modules stuck on 8: how to tell if they block the upgrade</title><link>https://initd.it/en/changelog/prestashop-modules-incompatible-9</link><guid isPermaLink="true">https://initd.it/en/changelog/prestashop-modules-incompatible-9</guid><description>A module stuck on PrestaShop 8 can block the move to 9. How to take inventory of modules, spot the risky ones and choose between updating, replacing or adapting them.</description><pubDate>Fri, 16 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;When a PrestaShop store puts off an upgrade, the core is almost never to blame. The sentence we hear most often is a different one: &quot;we can&apos;t upgrade because module X doesn&apos;t work with the new version&quot;. The management software module, the courier one, the one bought years ago for reseller discounts.&lt;/p&gt;
&lt;p&gt;It&apos;s a real problem, but rarely a dead end. In this article we look at how to take inventory of modules, how to recognise the ones that really block the move to PrestaShop 9, and the three ways to unblock them.&lt;/p&gt;
&lt;h2&gt;Why a module stops working&lt;/h2&gt;
&lt;p&gt;A &lt;strong&gt;module&lt;/strong&gt; is a piece of code that adds features to PrestaShop by attaching to predefined points, the &lt;em&gt;hooks&lt;/em&gt;, or by replacing core classes with &lt;em&gt;overrides&lt;/em&gt;. When PrestaShop changes major version, some of these things change:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;old functions and classes are removed or rewritten;&lt;/li&gt;
&lt;li&gt;back office pages move to &lt;strong&gt;Symfony&lt;/strong&gt;, and modules that changed them the old way no longer find their attachment point;&lt;/li&gt;
&lt;li&gt;the minimum PHP version changes, and code written for PHP 7 can throw errors on PHP 8.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A module written by the rules, with official hooks and APIs, usually needs little work. A module full of overrides and shortcuts needs much more. We covered this in the article on &lt;a href=&quot;/en/changelog/upgrade-to-prestashop-9&quot;&gt;what changes when moving to PrestaShop 9&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;The inventory: three questions for each module&lt;/h2&gt;
&lt;p&gt;First of all you need a list. From the back office module manager, you export or copy by hand every installed module, active or not. For each one you need three answers.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Is it still used?&lt;/strong&gt; It sounds trivial, but in a store a few years old some modules were installed for a test, replaced by something else or tied to a finished campaign. Every module removed is one problem less, and often a few queries less too: forgotten modules are a typical cause of a &lt;a href=&quot;/en/changelog/speed-up-prestashop&quot;&gt;slow PrestaShop&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Who maintains it?&lt;/strong&gt; Does the vendor still exist and publish updates? Is there already a version for 9? On the module page, the declared compatibility is the first clue.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Has it been modified?&lt;/strong&gt; A module bought and then patched by hand can no longer be updated without losing the changes. You need to know beforehand.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Got a list of modules and don&apos;t know which will survive 9?&quot; text=&quot;We take the inventory with you: compatibility, hand-made changes, up-to-date alternatives, with an estimate for each module to adapt.&quot; button=&quot;Request a check-up →&quot;}&lt;/p&gt;
&lt;h2&gt;Three paths: update, replace, adapt&lt;/h2&gt;
&lt;p&gt;Three groups come out of the list.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Update.&lt;/strong&gt; The vendor already has a version compatible with 9: you update it on the test copy and check it. It&apos;s the most common and cheapest case.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Replace.&lt;/strong&gt; The vendor has abandoned the module, but there&apos;s a solid, up-to-date alternative doing the same thing. You migrate settings and data where needed, and swap it. It costs some work once, but removes a problem for good.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Adapt.&lt;/strong&gt; The module is unique, and this is the work we do in &lt;a href=&quot;/en/development/prestashop&quot;&gt;PrestaShop development&lt;/a&gt;: custom-built, or doing something no alternative does the right way. Then you adapt the code to the version 9 APIs, test it on the copy and document it. A frequent example: the module linking PrestaShop to the management software, written years ago by a consultant who&apos;s no longer around. It works, but it uses two overrides and a removed function. Adapting it usually takes a few hours, much less than rewriting it.&lt;/p&gt;
&lt;h2&gt;The case of abandoned code&lt;/h2&gt;
&lt;p&gt;A module without maintenance isn&apos;t just an obstacle to upgrading: it&apos;s also a security risk, because discovered vulnerabilities won&apos;t get fixed. It&apos;s the same problem as abandoned dependencies in software in general, which we wrote about when covering &lt;a href=&quot;/en/changelog/npm-supply-chain-cooldown&quot;&gt;compromised packages and the supply chain&lt;/a&gt;. In the inventory, an abandoned module still in use always deserves an explicit decision: replace it or take it over.&lt;/p&gt;
&lt;p&gt;And it&apos;s worth remembering that staying behind has a cost that grows: we described it in &lt;a href=&quot;/en/changelog/prestashop-1-7-8-risks&quot;&gt;how much you risk by staying on PrestaShop 1.7 or 8&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;How to avoid it happening again&lt;/h2&gt;
&lt;p&gt;Two habits greatly reduce the problem at the next version:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;no hand edits&lt;/strong&gt; to bought modules: if you need an extra feature, write a separate module that hooks into the existing one;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;custom code by the rules&lt;/strong&gt;: official hooks and APIs, overrides only when there&apos;s no other way, everything versioned and documented. A &lt;a href=&quot;/en/changelog/what-is-a-ci-cd-pipeline&quot;&gt;release pipeline&lt;/a&gt; that tests the module on a copy of the store at every change does the rest.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Modules stuck on 8 are the real reason many stores don&apos;t move to PrestaShop 9, but they&apos;re almost never an insurmountable obstacle. You take inventory, remove the useless ones, update those with a new version, replace the abandoned ones and adapt the unique ones. The real work concentrates on a few modules, and it pays to know which before starting, with an estimate for each.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Is a module blocking your move to PrestaShop 9?&quot; text=&quot;We build custom PrestaShop modules and adapt existing ones to version 9, without touching the core and with the code delivered to you, documented.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://devdocs.prestashop-project.org/9/modules/&quot;&gt;Module development - PrestaShop 9&lt;/a&gt; - official documentation&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://devdocs.prestashop-project.org/9/basics/installation/system-requirements/&quot;&gt;System requirements - PrestaShop 9&lt;/a&gt; - official documentation&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://build.prestashop-project.org/news/2026/prestashop-9-2-0-available/&quot;&gt;PrestaShop 9.2 is available&lt;/a&gt; - PrestaShop Project, 30 September 2026&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>NIS2 and suppliers: what regulated clients will ask you for (October 2026 deadline)</title><link>https://initd.it/en/changelog/nis2-suppliers-what-to-prepare</link><guid isPermaLink="true">https://initd.it/en/changelog/nis2-suppliers-what-to-prepare</guid><description>For companies already on Italy&apos;s ACN list, the baseline NIS2 security measures fall due in October 2026 and suppliers end up in the contracts. What to prepare, measure by measure, in plain words.</description><pubDate>Wed, 14 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;If your company sells services to another company, sooner or later that client will send you a security questionnaire or a clause to sign. In 2026 it is more likely than ever: the European &lt;strong&gt;NIS2&lt;/strong&gt; directive, transposed in Italy by legislative decree 138/2024, is reaching its first big operational deadline.&lt;/p&gt;
&lt;p&gt;NIS2 is not only about giants. By law it covers medium and large companies in eighteen sectors (not just energy and healthcare, also digital services, manufacturing and more) and, in some cases, smaller businesses too. Those in scope are placed on a list kept by &lt;strong&gt;ACN&lt;/strong&gt;, Italy&apos;s national cybersecurity agency, and must adopt security measures and report incidents. If you are not on that list you have no such obligations by law. But if you sell something to someone who is, those obligations reach you anyway, through the contract.&lt;/p&gt;
&lt;p&gt;This article follows the Italian rules, because that is where most of our clients are: the directive is European, but dates and details are set by each country. We explain how the step from client to supplier works, which measures touch servers, backups and access, and where to start. An honest premise: this is not legal advice. These are the technical requirements ACN has published, translated into things you can check.&lt;/p&gt;
&lt;h2&gt;The deadlines: October 2026 is not for everyone&lt;/h2&gt;
&lt;p&gt;The calendar depends on when the entity was placed on the list. Every year, from 1 January to 28 February, the companies concerned register on the ACN portal, and the agency tells each of them whether it has been included. Two deadlines run from that notice:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;9 months&lt;/strong&gt; for reporting significant incidents (for the first group, listed in 2025, it started in January 2026);&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;18 months&lt;/strong&gt; for the baseline security measures (for the same group, October 2026).&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Entities listed for the first time in 2026 get more time: incident reporting from 1 January 2027 and baseline measures by 31 July 2027. So &quot;October 2026&quot; is not a universal date: it depends on the client in front of you. The measures are those of ACN Determination 379907 of 19 December 2025, in force since 15 January 2026: 37 measures for important entities and 43 for essential ones.&lt;/p&gt;
&lt;h2&gt;How it reaches a supplier: through contracts&lt;/h2&gt;
&lt;p&gt;The baseline measures include managing &lt;strong&gt;supply chain&lt;/strong&gt; risk. In practice the client must assess the suppliers that can affect its security and put security requirements into contracts. ACN&apos;s FAQ clarify the points that matter to you:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;contracts already in place do not have to be amended&lt;/strong&gt;; the requirements become mandatory for contracts signed, renewed or extended from the baseline-measures deadline onwards, unless there are documented legal or technical reasons not to;&lt;/li&gt;
&lt;li&gt;the client assesses the risk of each supply: how much you access its systems and data, how much a prolonged outage of yours would weigh, how much recovery costs and how long it takes;&lt;/li&gt;
&lt;li&gt;the requirements concern supplies with a potential security impact and must capture the substance of the measures, not copy their text.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;So what you will find written down is decided by the client. The common thread is that whoever runs their servers, their management software or their online shop will have to show they have in order the same things the client must have in order in-house.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Has a client already sent you a NIS2 questionnaire?&quot; text=&quot;We read it with you and turn it into things to check on your servers: what is already in place, what is missing and in what order to fix it.&quot; button=&quot;Get help with the questionnaire →&quot;}&lt;/p&gt;
&lt;h2&gt;The measures that touch servers, backups and access&lt;/h2&gt;
&lt;p&gt;The baseline specifications are broad and also cover governance, training and documentation. The ones closest to infrastructure, and so to the answers an IT supplier will have to give, are these:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Inventory of systems and services&lt;/strong&gt; (ID.AM, GV.OC): an up-to-date list of hardware, software, services and suppliers. The first step is knowing what runs, where and who manages it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Only software that still gets security updates&lt;/strong&gt; (PR.PS-02): only software, operating systems included, for which the availability of security updates is guaranteed may be installed, and patches must be applied &quot;without undue delay&quot;, barring justified and documented legal or technical reasons. This is the case of anyone staying on &lt;a href=&quot;/en/changelog/php-end-of-life-risks&quot;&gt;an end-of-life PHP version&lt;/a&gt;. A recent example is the two critical flaws of &lt;a href=&quot;/en/changelog/php2shell-critical-php-vulnerabilities&quot;&gt;PHP2Shell&lt;/a&gt;, fixed on 21 October 2026, and &lt;a href=&quot;/en/changelog/cve-2026-98432-linux-kernel-tcp-what-to-do&quot;&gt;the CVE-2026-98432 flaw in the Linux kernel&apos;s TCP code&lt;/a&gt;, whose patches arrived in waves between October and November. When the fixes come from the Linux distribution rather than php.net, we looked at &lt;a href=&quot;/en/changelog/php-backported-patches-nis2-supported&quot;&gt;what you can defend with backported patches&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Backups, offline too&lt;/strong&gt; (PR.DS-11): regular backups of data and configurations and, for relevant systems, offline copies as well. The &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;3-2-1 backup rule&lt;/a&gt; is a good starting point, as long as you test the restore.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Multi-factor authentication and separate accounts&lt;/strong&gt; (PR.AA-03, PR.AA-05): multi-factor authentication for relevant systems, based on risk, and administrative accounts distinct from ordinary ones, with different credentials.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Remote access listed, protected and logged&lt;/strong&gt; (PR.IR-01, PR.PS-04): a list of the systems reachable remotely and how, up-to-date firewalls, and logging of all remote access and of access with administrative privileges, with logs stored securely and preferably centrally. A &lt;a href=&quot;/en/changelog/bastion-host&quot;&gt;bastion host for SSH access&lt;/a&gt; solves most of it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Vulnerability management&lt;/strong&gt; (ID.RA-08): a written plan saying how vulnerabilities are found, tracked and fixed, including monitoring the channels of CSIRT Italia, the national team that handles cyber incidents.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Suppliers and the supply chain&lt;/strong&gt; (GV.SC, PR.PS-06): an inventory of suppliers with a contact and the type of supply and, for those who develop software, documented secure development practices. The supply chain theme concerns code too: see the story of the &lt;a href=&quot;/en/changelog/npm-supply-chain-cooldown&quot;&gt;compromised npm packages&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;One reassuring detail: many requirements apply &quot;at least to the relevant information and network systems&quot;, that is, those whose compromise would significantly affect the services. The client can limit where it applies them, and so where it will ask you for confirmation. Personal data remain a separate chapter, that of the GDPR, which we covered in &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR on the infrastructure side&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;Incidents: 24 hours, 72 hours, one month, and who warns whom&lt;/h2&gt;
&lt;p&gt;A NIS entity reports a significant incident to CSIRT Italia in three steps (article 25 of decree 138/2024):&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;an &lt;strong&gt;early warning&lt;/strong&gt; within 24 hours of becoming aware of the incident;&lt;/li&gt;
&lt;li&gt;a &lt;strong&gt;notification&lt;/strong&gt; within 72 hours, with a first assessment of severity and impact;&lt;/li&gt;
&lt;li&gt;a &lt;strong&gt;final report&lt;/strong&gt; within one month of the notification, with the cause and the measures taken.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;The clock starts when the entity has evidence of the incident, which is often after the incident happened. That is why the time between &quot;something happened on your server&quot; and &quot;the client knows&quot; matters: ACN indicates that clients should contractually ask suppliers to report security events promptly. If a supplier&apos;s incident hits the client&apos;s services, it is the client that notifies CSIRT, and the supplier as well if the incident is significant for it; for cloud services both notify, except for infrastructure (IaaS and hosting), where only the client does.&lt;/p&gt;
&lt;p&gt;In plain terms: you must be able to say within hours what happened, on which systems and with what consequences. Without logs, without a reachable contact and without a written procedure that is not possible.&lt;/p&gt;
&lt;h2&gt;Where to start, in one afternoon&lt;/h2&gt;
&lt;p&gt;You do not need a six-month project to begin. A sensible order:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Take stock&lt;/strong&gt; of servers, applications, external services and who manages them. A table is enough.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Close the doors&lt;/strong&gt;: multi-factor authentication wherever possible, separate administrative accounts, a list of remote access.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Test a restore&lt;/strong&gt; from backup, offline copy included. A backup never restored is a hope.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Write two pages&lt;/strong&gt;: the patching plan and the incident procedure, with the name and phone number of whoever answers.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Prepare a client sheet&lt;/strong&gt; summarising how you manage servers, backups, access and incidents: you will reuse it with every questionnaire.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Putting the technical side in order is our daily work of &lt;a href=&quot;/en/services/security&quot;&gt;securing Linux servers&lt;/a&gt;. An honest note: we are a technical consultancy, we do not do compliance audits or legal advice. For that you need a lawyer or a specialised consultant.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;NIS2 reaches suppliers through contracts: after the baseline-measures deadline, which falls in October 2026 for the first group of entities and in July 2027 for the new 2026 entrants, regulated clients will have to ask for security requirements from those who serve them. The requests will revolve around concrete things: inventory, patches on supported software, backups offline too, protected and logged access, a vulnerability plan and an incident procedure. Whoever starts now can answer in an orderly way instead of improvising in front of a questionnaire.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to be ready for the next NIS2 request from a client?&quot; text=&quot;We take the inventory, put access, backups and updates of your Linux servers in order, and document everything in a readable report you can attach to your answers.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.acn.gov.it/portale/en/faq/nis/misure-di-sicurezza-e-notifica-di-incidenti&quot;&gt;ACN, NIS FAQ: security measures and incident notification&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.acn.gov.it/portale/en/nis/modalita-specifiche-base&quot;&gt;ACN, Basic modes and specifications (Determination 379907/2025)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.acn.gov.it/portale/documents/d/guest/allegato-1-v2&quot;&gt;ACN, Annex 1: baseline security measures for important entities&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.acn.gov.it/portale/en/w/normativa-nis-date-e-informazioni-utili-per-un-implementazione-efficace&quot;&gt;ACN, NIS rules: dates and useful information&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.gazzettaufficiale.it/atto/serie_generale/caricaArticolo?art.versione=1&amp;amp;art.idGruppo=4&amp;amp;art.flagTipoArticolo=0&amp;amp;art.codiceRedazionale=24G00155&amp;amp;art.idArticolo=25&amp;amp;art.idSottoArticolo=1&amp;amp;art.idSottoArticolo1=10&amp;amp;art.dataPubblicazioneGazzetta=2024-10-01&amp;amp;art.progressivo=0&quot;&gt;Legislative decree 138/2024, article 25 (Gazzetta Ufficiale)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://eur-lex.europa.eu/eli/dir/2022/2555/oj&quot;&gt;Directive (EU) 2022/2555 (NIS2)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>PrestaShop 1.7 and 8 in 2026: how much you risk by staying behind</title><link>https://initd.it/en/changelog/prestashop-1-7-8-risks</link><guid isPermaLink="true">https://initd.it/en/changelog/prestashop-1-7-8-risks</guid><description>Store still on PrestaShop 1.7 or 8? What it means today in terms of unsupported PHP, security patches, modules and obligations to customers, and how to decide when to upgrade.</description><pubDate>Fri, 09 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Many PrestaShop stores still run on 1.7 or 8. They work, they sell, and the question &quot;why should I touch something that works?&quot; is fair. The problem is that &quot;works&quot; describes today, while the risks of an old version build up quietly: you don&apos;t see them until something happens.&lt;/p&gt;
&lt;p&gt;In this article we lay out, without alarmism, what it concretely means to stay on an old PrestaShop version at the end of 2026, and how to tell whether your store is in the safe zone or in the one to fix soon.&lt;/p&gt;
&lt;h2&gt;PrestaShop 8: the problem isn&apos;t PrestaShop, it&apos;s PHP&lt;/h2&gt;
&lt;p&gt;PrestaShop 8 is still maintained: the 8.2 branch receives &lt;strong&gt;security fixes only&lt;/strong&gt;, the latest being 8.2.8 of 18 August 2026. So far, no drama.&lt;/p&gt;
&lt;p&gt;The weak spot sits one level below. The official documentation lists PrestaShop 8 support up to &lt;strong&gt;PHP 8.1&lt;/strong&gt;, and PHP 8.1 left security support on &lt;strong&gt;31 December 2025&lt;/strong&gt;. In plain terms: a store on version 8 today necessarily runs on a PHP version that no longer gets fixes, even if PrestaShop itself is up to date. It&apos;s the same point we made about &lt;a href=&quot;/en/changelog/php-end-of-life-risks&quot;&gt;unsupported PHP&lt;/a&gt;: a vulnerability found tomorrow in PHP 8.1 will stay open.&lt;/p&gt;
&lt;p&gt;There&apos;s a practical effect too: many hosts remove unsupported PHP versions from their control panels. The day the host forces a newer version, a store on 8 may simply stop working.&lt;/p&gt;
&lt;h2&gt;PrestaShop 1.7: frozen for years&lt;/h2&gt;
&lt;p&gt;Version 1.7 has been in extended support since October 2022, and its latest published fix dates from 2024. It runs on even older PHP versions, all long out of support. A store on 1.7 in 2026 has piled up years of missing fixes, in the core and almost always in the modules too.&lt;/p&gt;
&lt;p&gt;No need to imagine theoretical scenarios. In July 2022 PrestaShop reported a real attack against stores on old versions: an &lt;em&gt;SQL injection&lt;/em&gt; vulnerability (a way to make the database run commands it shouldn&apos;t) was used to add a fake payment module to the checkout that sent card details to the attackers. Up-to-date versions with up-to-date modules were not vulnerable. How to recognise an attack like that is covered in &lt;a href=&quot;/en/changelog/hacked-prestashop-skimmer&quot;&gt;hacked PrestaShop&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Not sure which version your store really runs on?&quot; text=&quot;With the check-up we look at PrestaShop and PHP versions, abandoned modules and exposed points, and give you a list of priorities with costs.&quot; button=&quot;Request a check-up →&quot;}&lt;/p&gt;
&lt;h2&gt;The real risk is in the modules&lt;/h2&gt;
&lt;p&gt;Even with an up-to-date core, the store is as secure as the oldest module it has installed. Modules bought years ago and never updated, modules from vendors that closed down, custom modules written by someone who is no longer around: they&apos;re the most common way in, because nobody keeps an eye on them. And they&apos;re also the reason upgrades get postponed, because &quot;the management software module doesn&apos;t work with the new version&quot;.&lt;/p&gt;
&lt;p&gt;It&apos;s a vicious circle: the old module blocks the upgrade, the missed upgrade leaves the store exposed, and time makes the jump ever bigger. We go into detail in the article on &lt;a href=&quot;/en/changelog/upgrade-to-prestashop-9&quot;&gt;moving to PrestaShop 9&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;It&apos;s not just a technical matter&lt;/h2&gt;
&lt;p&gt;An online store handles personal data and, directly or through the payment provider, payment data. GDPR requires security measures appropriate to the state of the art, and software without fixes for years hardly qualifies; if there&apos;s a personal data breach, the authority must be notified within 72 hours of becoming aware of it. Those working with larger companies are also starting to get supplier questions tied to the &lt;a href=&quot;/en/changelog/nis2-suppliers-what-to-prepare&quot;&gt;NIS2 directive&lt;/a&gt;: &quot;which versions do you use, how do you update them?&quot;.&lt;/p&gt;
&lt;h2&gt;How to decide when to upgrade&lt;/h2&gt;
&lt;p&gt;A simple rule to see where you stand:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Up-to-date PrestaShop 9&lt;/strong&gt;: you&apos;re fine, just keep core and modules on the latest releases.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Up-to-date PrestaShop 8.2&lt;/strong&gt;: the core is covered, PHP isn&apos;t. Plan the move to 9 in the coming months, without rushing but without postponing forever.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;PrestaShop 8.0, 8.1 or 1.7&lt;/strong&gt;: you&apos;re behind on several fronts. First a security check, then an upgrade plan.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;You don&apos;t know your version&lt;/strong&gt;: that&apos;s the first problem to solve. The number is in the back office, at the bottom or on the Information page.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;If you want a full snapshot before deciding, the &lt;a href=&quot;/en/prestashop#fixes&quot;&gt;store check-up&lt;/a&gt; lines up version, modules, security and backups with priorities and costs. And a side benefit often shows up too: newer PHP versions are faster, one of the points we covered when discussing &lt;a href=&quot;/en/changelog/speed-up-prestashop&quot;&gt;slow PrestaShop&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Staying on PrestaShop 1.7 or 8 in 2026 doesn&apos;t mean you&apos;ve already been attacked, but it does mean running on unsupported PHP versions and, almost always, on modules nobody updates any more. 8.2 still gets security fixes, 1.7 hasn&apos;t for years. The risk doesn&apos;t go away by waiting: it grows, along with the cost of the jump. It pays to know where you stand, pick a date and get there with a plan.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want a plan to upgrade your PrestaShop store?&quot; text=&quot;We look at version, modules and server, tell you what&apos;s urgent and what can wait, and move the store to 9 testing everything on a copy first.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://build.prestashop-project.org/news/2026/prestashop-8-2-8-security-release/&quot;&gt;PrestaShop 8.2.8 security release&lt;/a&gt; - PrestaShop Project, 18 August 2026&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://build.prestashop-project.org/news/2022/prestashop-1-7-8-8-maintenance-release/&quot;&gt;PrestaShop 1.7.8.8 maintenance release&lt;/a&gt; - PrestaShop Project, October 2022&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://build.prestashop-project.org/news/2024/prestashop-1-7-8-11-maintenance-release/&quot;&gt;PrestaShop 1.7.8.11 maintenance release&lt;/a&gt; - PrestaShop Project, 2024&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://devdocs.prestashop-project.org/8/basics/installation/system-requirements/&quot;&gt;System requirements - PrestaShop 8&lt;/a&gt; - official documentation&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/eol.php&quot;&gt;Unsupported Branches&lt;/a&gt; - php.net, end-of-life dates for PHP versions&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://build.prestashop-project.org/news/2022/major-security-vulnerability-on-prestashop-websites/&quot;&gt;Major security vulnerability on PrestaShop websites&lt;/a&gt; - PrestaShop Project, July 2022&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Moving to PrestaShop 9: what changes, what breaks and how to prepare</title><link>https://initd.it/en/changelog/upgrade-to-prestashop-9</link><guid isPermaLink="true">https://initd.it/en/changelog/upgrade-to-prestashop-9</guid><description>Moving to PrestaShop 9 from 1.7 or 8: PHP requirements, modules and theme to check, what&apos;s new in 9.2, and a test-copy method to upgrade the store without stopping sales.</description><pubDate>Tue, 06 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone running a PrestaShop store eventually asks the same question: is it worth moving to version 9, or is it better to leave everything as it is while it works? The honest answer is that &quot;while it works&quot; has an expiry date, and the store doesn&apos;t set it: it&apos;s set by the PHP versions your host keeps offering, by modules that stop being updated, by vulnerabilities that only get fixed in new versions.&lt;/p&gt;
&lt;p&gt;The good news is that moving to 9 is not a leap in the dark. You prepare it, test it on a copy and take it live in a short window. In this article we look at what really changes, what usually breaks, and the method that avoids finding out on the first day of the sales.&lt;/p&gt;
&lt;h2&gt;What really changes with PrestaShop 9&lt;/h2&gt;
&lt;p&gt;The most concrete difference is under the hood: PrestaShop 9 requires &lt;strong&gt;at least PHP 8.1&lt;/strong&gt; and, with 9.2 released on 30 September 2026, supports up to PHP 8.5. PHP is the language PrestaShop is written in, and every version has a limited life: when it ends, it no longer receives security fixes. We covered this in the article on &lt;a href=&quot;/en/changelog/php-end-of-life-risks&quot;&gt;the risks of an unsupported PHP&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Here&apos;s the point: PrestaShop 8 stops at PHP 8.1, and PHP 8.1 left security support on 31 December 2025. A store on version 8 today necessarily runs on a PHP version that no longer gets patches. Version 9 is the way back to a supported PHP.&lt;/p&gt;
&lt;p&gt;Then there are the visible new features:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;a native &lt;strong&gt;one-page checkout&lt;/strong&gt;, introduced in 9.2, which the merchant can switch on or off from the back office;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Hummingbird&lt;/strong&gt; as the default theme since 9.1, lighter and more modern than the old Classic;&lt;/li&gt;
&lt;li&gt;a back office that keeps moving to &lt;strong&gt;Symfony&lt;/strong&gt;, the PHP framework PrestaShop is rebuilding its admin pages on.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;What usually breaks&lt;/h2&gt;
&lt;p&gt;The PrestaShop core upgrades well. What breaks is almost always around it:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;third-party modules&lt;/strong&gt; written for 1.7 or 8 that use removed or changed functions. Many modules on sale are still declared compatible only up to 8;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;overrides&lt;/strong&gt;, meaning core classes replaced by a module or a developer: if the core changes, the override no longer fits;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;themes&lt;/strong&gt; bought years ago and customised directly, without a child theme: they need adapting or replacing;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;integrations&lt;/strong&gt; with management software, couriers and marketplaces, which often go through those very modules.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A typical example: a store with 18 modules. Twelve already have a version for 9, three are no longer used and can be removed, two are replaced with up-to-date alternatives, and one, custom-built years ago to link the management software, needs adapting. That&apos;s where the work concentrates, not in the core.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Not sure which modules will survive version 9?&quot; text=&quot;We take inventory of your store: version, modules, theme and available PHP, with a list of what&apos;s compatible and what needs adapting.&quot; button=&quot;Request a check-up →&quot;}&lt;/p&gt;
&lt;h2&gt;The method: the copy first, then the real store&lt;/h2&gt;
&lt;p&gt;The most expensive mistake is upgrading the live store directly. The method we use is always the same.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Inventory&lt;/strong&gt;: current version, list of modules with their compatibility, theme, PHP version available on the host.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Full backup&lt;/strong&gt; of files and database, and verified: a backup nobody ever tried to restore is a hope, not a plan. The &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;3-2-1 backup rule&lt;/a&gt; is still the reference.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Test copy&lt;/strong&gt; of the store, separate from the real one, where the upgrade happens.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Tests on what makes sales&lt;/strong&gt;: search, categories, product page, cart, checkout, payments, shipping, order emails.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Go-live&lt;/strong&gt; in an agreed, low-traffic window, with the backup ready to roll back.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Done this way, the real store stays open for the whole testing period; the final maintenance window usually takes less than an hour.&lt;/p&gt;
&lt;h2&gt;The theme: adapt or change?&lt;/h2&gt;
&lt;p&gt;The theme is the part customers see, so decisions weigh most there. There are three paths: a theme already compatible with 9, which you just update; a theme to adapt, with development work that needs estimating; or switching to Hummingbird, the default theme, customised with colours, logo and little else. The third path is often the cheapest in the long run, because a default theme gets updated along with PrestaShop.&lt;/p&gt;
&lt;h2&gt;How much it costs and how long it takes&lt;/h2&gt;
&lt;p&gt;The cost depends on three variables: how many third-party modules there are, how many need adapting and how customised the theme is. For a store with around fifteen modules and a compatible theme, the move takes a few days, mostly of checking. We handle it with the &lt;a href=&quot;/en/fixes/prestashop-9-upgrade&quot;&gt;upgrade to PrestaShop 9&lt;/a&gt;, with the price set in the quote and modules to adapt estimated separately before we start.&lt;/p&gt;
&lt;p&gt;If the store is also slow, it&apos;s worth using the upgrade to fix the causes: they&apos;re often the ones described in the article on &lt;a href=&quot;/en/changelog/speed-up-prestashop&quot;&gt;slow PrestaShop&lt;/a&gt;, and a newer PHP alone already brings an improvement.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;PrestaShop 9 is not a cosmetic update: it brings the store back to PHP versions that still receive security fixes, and with 9.2 it adds new features such as the one-page checkout. The core upgrades well; the work lies in modules, overrides, theme and integrations. With an inventory done first, a test copy and a verified backup, the move happens without stopping sales. Putting it off costs nothing today, but every month makes the jump bigger, just like &lt;a href=&quot;/en/changelog/php2shell-critical-php-vulnerabilities&quot;&gt;PHP vulnerabilities piling up&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to move your store to PrestaShop 9?&quot; text=&quot;We do the upgrade on a test copy, check modules, checkout and payments, and go live with a backup ready. We build PrestaShop modules and run the servers they run on.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://build.prestashop-project.org/news/2026/prestashop-9-2-0-available/&quot;&gt;PrestaShop 9.2 is available&lt;/a&gt; - PrestaShop Project, 30 September 2026&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://devdocs.prestashop-project.org/9/basics/installation/system-requirements/&quot;&gt;System requirements - PrestaShop 9&lt;/a&gt; - official documentation&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://devdocs.prestashop-project.org/8/basics/installation/system-requirements/&quot;&gt;System requirements - PrestaShop 8&lt;/a&gt; - official documentation&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/eol.php&quot;&gt;Unsupported Branches&lt;/a&gt; - php.net, end-of-life dates for PHP versions&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Is Your Site Slow? Measure Before You Buy a More Powerful Server</title><link>https://initd.it/en/changelog/slow-website-what-to-do</link><guid isPermaLink="true">https://initd.it/en/changelog/slow-website-what-to-do</guid><description>A slow site loses visitors, sales and ranking. Why a more powerful server almost never fixes it, which two numbers to check for free, and the real causes of slowness.</description><pubDate>Sun, 20 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;A slow site isn&apos;t just annoying: it&apos;s a cost. Someone who opens a page and watches it struggle to load leaves, and with them go visits, sales and trust. Google, in turn, factors speed into who it shows first: a slow site starts further back in search results too.&lt;/p&gt;
&lt;p&gt;Faced with a slow site, the instinct is almost always the same: &quot;let&apos;s get a more powerful server&quot;. It is the most natural reaction and, nine times out of ten, it is also the wrong one. A bigger server hides the problem for a few months, costs you more every month, and then the slowness comes back, because the cause was never the horsepower. The rule is one: &lt;strong&gt;measure first, spend later&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Let&apos;s look at why the hardware is rarely the answer, which two numbers you can check yourself for free, and where slowness actually comes from.&lt;/p&gt;
&lt;h2&gt;Why a more powerful server (usually) doesn&apos;t fix it&lt;/h2&gt;
&lt;p&gt;The bottleneck of a slow site is almost never raw compute power. In the vast majority of cases it is something else: huge unoptimised images, a missing or misconfigured cache, badly written database queries, or too many third-party scripts dragging the load down. Doubling CPU and memory touches none of these causes: it papers over them at a steep price, until traffic grows and the problem resurfaces.&lt;/p&gt;
&lt;p&gt;The comparison is city traffic. If the roads are jammed because of too many poorly timed traffic lights, buying a faster car won&apos;t get you there sooner: you sit in the same queue, just in a more expensive vehicle. Speed helps when the road is clear, not when the problem is how the route is organised.&lt;/p&gt;
&lt;h2&gt;The two numbers to check, for free&lt;/h2&gt;
&lt;p&gt;Before spending a cent, look at how the site is actually doing. Two indicators are enough, and you&apos;ll find them free in tools like Google&apos;s PageSpeed Insights, simply by pasting in the site&apos;s address:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;LCP&lt;/strong&gt; (Largest Contentful Paint): how long the largest element on the page takes to appear, usually the image or headline at the top. It depends heavily on how quickly the server responds, an aspect with a precise name: the &lt;a href=&quot;/en/changelog/ttfb-explained&quot;&gt;response time, or TTFB&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;INP&lt;/strong&gt;: how responsive the page is when you click or type in it. A high value tells the story of a page weighed down by too much code running in the browser, often third-party scripts. It is the metric that &lt;a href=&quot;/en/changelog/inp-core-web-vital&quot;&gt;replaced the old FID&lt;/a&gt; among Google&apos;s Core Web Vitals.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;These two numbers tell you &lt;em&gt;where&lt;/em&gt; to look. A high LCP points toward the server and loading; a high INP points toward scripts and code. It is the difference between knowing and guessing.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Is your site slow and you can&apos;t tell why?&quot; text=&quot;We measure LCP, INP and TTFB, find the real bottleneck and tell you what&apos;s worth fixing, before you spend on hardware.&quot; button=&quot;Ask for an analysis →&quot;}&lt;/p&gt;
&lt;h2&gt;The real causes of slowness, in order of frequency&lt;/h2&gt;
&lt;p&gt;In practice, a site&apos;s slowness almost always comes from these causes, and it helps to know them because each has a different, targeted fix:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Huge unoptimised images.&lt;/strong&gt; A 4 MB photo loaded as-is weighs more than the rest of the page combined. Resizing and compressing them well is often the single change that pays off most.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Missing or misconfigured cache.&lt;/strong&gt; Without a cache, the server rebuilds every page from scratch on each visit. A cache done right, server-side and browser-side, cuts times sharply.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Slow database queries.&lt;/strong&gt; On CMS and e-commerce this is a classic: a single badly written query can freeze whole screens. It is the heart of the problem when, for example, &lt;a href=&quot;/en/changelog/speed-up-prestashop&quot;&gt;a PrestaShop store slows down&lt;/a&gt; at peak times.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Too many third-party scripts.&lt;/strong&gt; Chat, tracking pixels, marketing tags, widgets: each adds weight and delay. They often pile up by the dozen without anyone reviewing them.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;An undersized or misconfigured server.&lt;/strong&gt; Yes, sometimes the server really is the cause, but you find that from a measured high TTFB, not from a hunch.&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;When the server really is to blame&lt;/h2&gt;
&lt;p&gt;It is worth saying honestly: sometimes the cause really is the hardware, an overloaded shared host or a machine undersized for the real traffic. But even then the answer is rarely &quot;buy more power&quot;. Often it is enough to add a caching layer (Redis, Varnish), tune the web server and database properly, and the same hardware handles three times the load. You move to a bigger server only after measuring that you truly need it, not as a first blind attempt.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;A slow site is rarely solved by buying hardware. First you measure LCP, INP and the server&apos;s response time; then you act on the real cause, which in the vast majority of cases is heavy images, a missing cache, slow queries or scripts too many. Often the same hardware, tuned well, runs three times faster, at a far lower cost than a bigger server that hides the problem for a few months. If you want to understand where your site&apos;s slowness comes from before you spend, that is the kind of analysis we start from.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want a fast site without throwing money at hardware?&quot; text=&quot;We measure, find the real bottleneck and optimise cache, images, queries and server configuration, with before-and-after numbers.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/articles/vitals&quot;&gt;Core Web Vitals - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developers.google.com/speed/docs/insights/v5/about&quot;&gt;About PageSpeed Insights - Google for Developers&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/articles/lcp&quot;&gt;Largest Contentful Paint (LCP) - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Your Quotes Keep Landing in Spam? Here&apos;s Why (and How to Fix It)</title><link>https://initd.it/en/changelog/quote-emails-going-to-spam</link><guid isPermaLink="true">https://initd.it/en/changelog/quote-emails-going-to-spam</guid><description>Why quotes and business emails end up in spam on Gmail and Outlook, how to tell if it is happening to you, and how it is actually fixed, without switching email provider.</description><pubDate>Sun, 20 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;You send a quote, you wait, and nobody replies. The natural conclusion is that the client wasn&apos;t interested. Often, though, the truth is different: that email never arrived. It landed in the spam folder, or it was rejected before it even reached the inbox. A deal lost without even knowing you lost it.&lt;/p&gt;
&lt;p&gt;It isn&apos;t bad luck, and it is almost never about what you wrote. In the vast majority of cases it is a precise, fixable technical problem in how your domain proves its own identity. Gmail, Outlook and the other big providers decide in a fraction of a second whether to trust an email, and if your domain can&apos;t prove it is really you, the default answer is: into spam.&lt;/p&gt;
&lt;p&gt;The good news is that this problem can be diagnosed in half an hour and fixed in an afternoon, and it &lt;strong&gt;does not require changing email provider&lt;/strong&gt;. Let&apos;s look at why it happens and how to tell if it affects you too.&lt;/p&gt;
&lt;h2&gt;Why a legitimate email ends up in spam&lt;/h2&gt;
&lt;p&gt;Email has a birth defect: the sender is easy to forge. The address shown in the &quot;From&quot; field is like a name written by hand on the back of an envelope, nothing guarantees it on its own. That is why providers filter aggressively, and a sender they can&apos;t verify is, by definition, suspicious.&lt;/p&gt;
&lt;p&gt;To decide, they check three public &quot;documents&quot; of your domain: &lt;strong&gt;SPF&lt;/strong&gt;, &lt;strong&gt;DKIM&lt;/strong&gt; and &lt;strong&gt;DMARC&lt;/strong&gt;. If they are missing, broken or not aligned, your email starts at a disadvantage. On top of that comes &lt;strong&gt;reputation&lt;/strong&gt;: the IP address you send from has a history, and if spam went out from there in the past, or if your domain has never been authenticated, filters treat you with suspicion.&lt;/p&gt;
&lt;p&gt;Think of customs. A parcel with its paperwork in order goes through; one without a verifiable sender gets opened, set aside or returned. Your email is that parcel, and the three checks are its paperwork.&lt;/p&gt;
&lt;h2&gt;The three checks that decide whether you get read&lt;/h2&gt;
&lt;p&gt;Without going technical, here is what each one does:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;SPF&lt;/strong&gt; declares &lt;em&gt;which servers are allowed&lt;/em&gt; to send for your domain. If the email comes from a server not on the list, it is suspicious.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;DKIM&lt;/strong&gt; adds a &lt;em&gt;signature&lt;/em&gt; proving the message really comes from you and wasn&apos;t altered along the way.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;DMARC&lt;/strong&gt; ties the first two to the address the client actually sees, tells the provider what to do when something doesn&apos;t add up, and sends you reports on who is sending in your name.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Anyone who wants the details will find them in the full guide on &lt;a href=&quot;/en/changelog/spf-dkim-dmarc&quot;&gt;what SPF, DKIM and DMARC are&lt;/a&gt;. The point for you is a different one: since 2024 Gmail and Yahoo &lt;strong&gt;explicitly require&lt;/strong&gt; them from senders of any real volume, and use them as a signal for everyone. Not having them set up today means sending uphill.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do your quotes actually reach your clients?&quot; text=&quot;We check SPF, DKIM, DMARC and your domain reputation, and test real delivery to Gmail and Outlook until the mail lands in the inbox.&quot; button=&quot;Ask for a check →&quot;}&lt;/p&gt;
&lt;h2&gt;How to tell if it&apos;s your case, without being technical&lt;/h2&gt;
&lt;p&gt;There are signs it&apos;s time to look under the hood:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Clients tell you &quot;I never got anything&quot;, when you did send the email.&lt;/li&gt;
&lt;li&gt;Quotes to Gmail, Outlook or corporate addresses go unanswered more than usual.&lt;/li&gt;
&lt;li&gt;Transactional emails from your app or e-commerce (order confirmations, password resets) don&apos;t arrive.&lt;/li&gt;
&lt;li&gt;Years ago someone connected a newsletter platform or a CRM to your domain, and nobody checked the configuration since.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The quick test you can run yourself: send a message to a Gmail address and to an Outlook one, and see if it lands in spam. Then open the received email and look, under &quot;show original&quot; or &quot;details&quot;, for the lines that say &lt;code&gt;spf=pass&lt;/code&gt; or &lt;code&gt;spf=fail&lt;/code&gt;, &lt;code&gt;dkim=pass&lt;/code&gt; or &lt;code&gt;dkim=fail&lt;/code&gt;. A &quot;fail&quot; is the warning bell. There are also free online tools that, given your domain, tell you whether the three records exist and are consistent.&lt;/p&gt;
&lt;h2&gt;What does NOT fix the problem&lt;/h2&gt;
&lt;p&gt;Worth stating, because these are the wrong turns people try most often:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Buying more powerful hosting or a bigger server&lt;/strong&gt; is beside the point: deliverability is a matter of DNS and reputation, not horsepower.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Rewriting the email text&lt;/strong&gt; or dropping attachments helps little if the domain isn&apos;t authenticated: the filter decides before it reads the content.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Adding &quot;this is not spam&quot; in the footer&lt;/strong&gt; has no effect on filters whatsoever.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A domain&apos;s reputation takes months to build and burns in an afternoon, for example through a compromised mailbox sending spam without your knowledge. That is why the right move is to configure the three checks properly, start DMARC in observe-only mode to learn who really sends in your name, and only then tighten the rules. First you look, then you decide.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Quotes ending up in spam are rarely bad luck: they are your domain failing to prove it is you. The combination of SPF, DKIM, DMARC and reputation decides whether a legitimate email reaches the inbox or gets discarded. It is a problem you can diagnose and fix in an afternoon, without changing provider, and every email that gets delivered again is a deal you were silently losing. If you would rather not handle it yourself, it is exactly the kind of work we do.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want your quotes to arrive, and stay out of spam?&quot; text=&quot;We analyse your domain&apos;s DNS, fix authentication and reputation and verify delivery on the real providers, with everything documented line by line.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://support.google.com/a/answer/81126?hl=en&quot;&gt;Email sender guidelines - Google Workspace Admin Help&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://learn.microsoft.com/en-us/troubleshoot/exchange/mail-flow/smtp-submission-improvements&quot;&gt;Sending mail to Outlook.com - Microsoft Learn&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc9989.html&quot;&gt;RFC 9989 - Domain-based Message Authentication, Reporting, and Conformance (DMARC)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>MikroTik RouterOS under attack: the exploited SSH flaws and what to do now</title><link>https://initd.it/en/changelog/mikrotik-routeros-ssh-vulnerabilities</link><guid isPermaLink="true">https://initd.it/en/changelog/mikrotik-routeros-ssh-vulnerabilities</guid><description>Two RouterOS flaws, exploited in the wild since 2 September 2026, let anyone take over a MikroTik router with SSH exposed, no credentials needed. Who is at risk, how to check, how to update.</description><pubDate>Mon, 07 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;On 3 September 2026 MikroTik published a security update for &lt;strong&gt;RouterOS&lt;/strong&gt;, the operating system of its routers, calling it &quot;important&quot; and saying nothing about what it fixed. Two days later CERT Polska, the Polish national incident response team that had found and reported the problems, broke the silence: six vulnerabilities, two of which combined let anyone &lt;strong&gt;take full control of the router without knowing a single password&lt;/strong&gt;, as long as the SSH service is reachable from the internet. The attack chain has a name, &lt;strong&gt;MikroTrick&lt;/strong&gt;, and it is already in use: the intrusions traced so far go back to at least 2 September, the day before the patches.&lt;/p&gt;
&lt;p&gt;MikroTik routers are everywhere a solid network device at a modest price is needed: offices, professional practices, small providers, branch sites linked by VPN, colocation racks. Often a technician installed them years ago, they work, and nobody has opened them since. That is precisely the profile of device this story puts at risk.&lt;/p&gt;
&lt;p&gt;Below: what was found, who is genuinely exposed and who is not, how to tell whether a router has already been breached, how to update and what to change in the configuration so it does not happen again. The facts come from the MikroTik bulletin, the CERT Polska advisory and the official documentation, all linked at the end.&lt;/p&gt;
&lt;h2&gt;What was found: six flaws, two are enough to get in without a password&lt;/h2&gt;
&lt;p&gt;The two vulnerabilities that make up the MikroTrick chain both affect the RouterOS &lt;strong&gt;SSH&lt;/strong&gt; server, the service that lets you administer the router from a remote command line. Both are rated &lt;strong&gt;9.2 out of 10&lt;/strong&gt; in severity.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;CVE-2026-67276&lt;/strong&gt;: when a user authenticates with a cryptographic key instead of a password, RouterOS did not verify the whole key, only part of it. Anyone who knows the public part of an authorised user&apos;s key can build a different key the router accepts anyway, and log in as that user without holding the private key. It is a lock that checks the shape of the key but not the teeth.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;CVE-2026-86060&lt;/strong&gt;: the SSH login procedure mishandled usernames beginning with a disallowed character. With a crafted name, a session that should have limited permissions ends up with &lt;strong&gt;full administrator privileges&lt;/strong&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Taken one at a time, each has prerequisites. Combined, according to CERT Polska, they allow &quot;full control of the device without authentication&quot;. The other four flaws are less severe but not negligible: one in the &lt;em&gt;bandwidth-test&lt;/em&gt; service (the built-in bandwidth measurement tool, port 2000) lets an unauthenticated client read fragments of system memory or reboot the router; one in the WebFig web interface allows reading protected files, including configuration archives that contain credentials; the last two affect the built-in SSH client and X.509 certificate handling.&lt;/p&gt;
&lt;p&gt;One detail explains the race against the clock: MikroTik released the fix without details, but RouterOS patches are public and can be compared. By 4 September an independent analysis was already online that, by diffing version 7.23.3 against 7.23.4, had reconstructed how the flaws worked. At that point staying quiet helped nobody, and CERT Polska published its advisory on the 5th.&lt;/p&gt;
&lt;h2&gt;Who is genuinely at risk (and who is not)&lt;/h2&gt;
&lt;p&gt;MikroTik writes that &quot;most configurations are not at risk&quot;. That is true, with one important caveat. A MikroTik router&apos;s default configuration blocks access to management services from the WAN port, so a device installed with factory settings does not expose SSH to the internet and cannot be attacked from outside.&lt;/p&gt;
&lt;p&gt;The problem is everyone else: routers configured from scratch by a technician, those where firewall rules were removed &quot;to make something work&quot;, those where SSH was opened for convenient remote management, those run by providers and data centres. The Shadowserver Foundation, a non-profit that scans the internet on behalf of national CERTs, counted roughly &lt;strong&gt;122,500 MikroTik routers with SSH reachable&lt;/strong&gt; by anyone on 5 September. Each of those, if not updated, can be taken with a script.&lt;/p&gt;
&lt;p&gt;Many versions are affected. When a user on the official forum asked whether 7.20 and 7.21 were vulnerable too, MikroTik staff replied that &quot;many years of versions&quot; are affected: the fix exists only from the 3 September releases onward. How new the router is does not matter, how new the operating system is does.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Not sure whether the MikroTik router in your office or rack has SSH open to the internet?&quot; text=&quot;We check from outside and from inside: RouterOS version, exposed services, traces of unusual logins. We tell you whether it is clean and what to close.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;How to tell whether the router has already been breached&lt;/h2&gt;
&lt;p&gt;Before updating it is worth looking, because the update closes the door but does not evict whoever is already inside. CERT Polska describes what the observed attacks leave behind:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;the event log shows lines such as &lt;code&gt;login failure for user -2 from &amp;lt;ip&amp;gt; via ssh&lt;/code&gt; followed shortly by &lt;code&gt;user &amp;lt;name&amp;gt; added by ssh:-2@&amp;lt;ip&amp;gt;&lt;/code&gt;: that &lt;code&gt;-2&lt;/code&gt; in place of a username is the signature of the exploited flaw;&lt;/li&gt;
&lt;li&gt;an &lt;strong&gt;unknown administrator account&lt;/strong&gt; is created, called &lt;code&gt;ops&lt;/code&gt; in the observed cases;&lt;/li&gt;
&lt;li&gt;scripts, scheduled tasks, proxies or tunnels appear that nobody configured.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;From the router console, these are the checks:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;/log/print where message~&quot;-2&quot;
/system/history/print
/user/print
/system/script/print
/system/scheduler/print
/ip/proxy/print
/ip/socks/print
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;If the log has already been overwritten, and on a router that happens fast, the absence of suspicious lines proves nothing: what counts are the users, scripts and rules you do not recognise.&lt;/p&gt;
&lt;p&gt;MikroTik added an extra safety net. On first boot, the fixed versions examine the configuration for known traces of compromise: if they find any, they disable the suspicious entries, write a critical message to the log and put the router into &lt;strong&gt;Flagged&lt;/strong&gt; status. You check it with &lt;code&gt;/system/device-mode/print&lt;/code&gt;. In that state the router keeps working, but it will not let you create new scheduled tasks, proxies, VPN tunnels or shares until someone intervenes in person: clearing the marker takes a command confirmed by pressing the physical reset button or power-cycling the device. The documentation is clear on two points: Flagged status does not delete the configuration, which still has to be inspected line by line, and the mechanism only recognises known traces, so an unflagged router is not necessarily clean.&lt;/p&gt;
&lt;h2&gt;What to do now: update, then verify&lt;/h2&gt;
&lt;p&gt;The fixed versions are &lt;strong&gt;7.24.2&lt;/strong&gt; (&lt;em&gt;stable&lt;/em&gt; channel), &lt;strong&gt;7.23.4&lt;/strong&gt; (&lt;em&gt;long-term&lt;/em&gt;), &lt;strong&gt;6.49.21&lt;/strong&gt; for those still on the old version 6 series, and 7.25beta3 for the development channel. From the console:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;/system/package/update/check-for-updates
/system/package/update/install
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The router reboots by itself when done: on a production device you need a window of a few minutes. Before updating, export the configuration with &lt;code&gt;/export file=before-update&lt;/code&gt; and download the file, for the same reason you take &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;a backup before any intervention&lt;/a&gt;: if something goes wrong, you roll back.&lt;/p&gt;
&lt;p&gt;After the update, not before:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;check &lt;code&gt;/system/device-mode/print&lt;/code&gt; and the event log for the Flagged message;&lt;/li&gt;
&lt;li&gt;repeat the checks from the previous section on users, scripts, scheduled tasks, proxies and tunnels;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;change every password&lt;/strong&gt; on the router and regenerate the users&apos; SSH keys, because an attacker with administrative access may have read the full configuration, credentials included;&lt;/li&gt;
&lt;li&gt;if the router acted as a VPN concentrator, treat the tunnel keys as compromised too and regenerate them.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;If a router shows signs of compromise and you cannot reconstruct what was touched, the safest route is a factory reset onto the fixed version and a rebuild from a verified export taken before the incident.&lt;/p&gt;
&lt;p&gt;Those who cannot update right away have a single temporary alternative, given by both MikroTik and CERT Polska: make SSH, the web interface (WWW and WWW-SSL) and the bandwidth-test service unreachable from outside. It shrinks the surface, it does not solve the problem.&lt;/p&gt;
&lt;h2&gt;Updating is not enough: management access must not be exposed&lt;/h2&gt;
&lt;p&gt;The most useful lesson in this story is not about MikroTik. A router&apos;s administrative interfaces (SSH, WebFig, Winbox, the API) should never be reachable from the internet, regardless of the flaw of the day. It is the same principle by which &lt;a href=&quot;/en/changelog/bastion-host&quot;&gt;a server&apos;s SSH port is not exposed&lt;/a&gt; and by which automated password guessing, &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;thousands of attempts a day against anything that answers&lt;/a&gt;, hits routers too: back in July CISA, the US cybersecurity agency, had already published two advisories on the RouterOS API, one of which notes that it does not limit failed login attempts.&lt;/p&gt;
&lt;p&gt;In practice, the configuration we recommend and apply:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;/ip/firewall/address-list/add list=management address=192.168.10.0/24
/ip/firewall/filter/add chain=input protocol=tcp dst-port=22,80,443,2000,8291,8728,8729 src-address-list=!management action=drop place-before=0
/ip/service/disable telnet,ftp,www,api,api-ssl
/tool/bandwidth-server/set enabled=no
/ip/ssh/set strong-crypto=yes
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The first rule drops any connection to the management services that does not come from the internal administration network. The others switch off what is not needed. MikroTik staff, again on the forum, pointed out that restricting the source address in the service itself (&lt;code&gt;/ip/service/set ssh address=...&lt;/code&gt;) is less effective than a firewall rule, because the firewall drops the packet before the service ever receives it.&lt;/p&gt;
&lt;p&gt;For remote management the right answer is &lt;a href=&quot;/en/changelog/wireguard-vpn&quot;&gt;a VPN such as WireGuard&lt;/a&gt;, which RouterOS has integrated for years: you enter the tunnel with a key, and only from inside the tunnel can you reach SSH. It is also the explicit recommendation of the MikroTik bulletin. The rest is discipline: an inventory of devices with version and date of last update, and a rule that a router&apos;s security updates are applied within days, as with &lt;a href=&quot;/en/changelog/proxmox-8-end-of-life-upgrade&quot;&gt;any other software that holds up production&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Six flaws in RouterOS, two of which together let anyone take a MikroTik router with SSH exposed without any credential, have been exploited in the wild since 2 September 2026. Versions 7.24.2, 7.23.4 and 6.49.21 fix them and add an automatic check that marks routers with known traces of compromise as Flagged. The factory configuration is not exposed, but tens of thousands of hand-configured routers are. Check the log and the users, update, change the passwords, and close management access from the internet for good by moving it inside a VPN.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Do you have MikroTik routers in the office, in a rack or at your clients&apos; sites and want them secured once and for all?&quot; text=&quot;We take the inventory, update in an agreed window, check for traces of compromise, close the management services behind WireGuard and leave you with a documented configuration. We manage networks and Linux servers for SMEs, practices and agencies.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://mikrotik.com/supportsec/september-2026-vulnerability/&quot;&gt;MikroTik, &quot;September 2026 vulnerability&quot; bulletin with fixed versions and recommendations&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://cert.pl/en/posts/2026/09/vulnerabilities-in-mikrotik-routeros-actively-exploited/&quot;&gt;CERT Polska, advisory on actively exploited RouterOS vulnerabilities (5 September 2026)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://forum.mikrotik.com/t/important-security-update/272851&quot;&gt;MikroTik, &quot;Important security update&quot; announcement on the official forum, with staff clarifications&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://help.mikrotik.com/docs/spaces/ROS/pages/93749258/Device-mode&quot;&gt;RouterOS documentation, Device-mode and Flagged status&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://help.mikrotik.com/docs/spaces/ROS/pages/328353/Securing+your+router&quot;&gt;RouterOS documentation, Securing your router&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.cisa.gov/news-events/ics-advisories/icsa-26-209-05&quot;&gt;CISA, advisory ICSA-26-209-05 on RouterOS API authentication (July 2026)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Pipeline secrets: how not to end up with your keys on GitHub</title><link>https://initd.it/en/changelog/pipeline-secrets</link><guid isPermaLink="true">https://initd.it/en/changelog/pipeline-secrets</guid><description>Where the tokens and passwords a CI/CD pipeline needs should live: why a secret in the repository cannot be deleted, masking and protected branches, short-lived identities with OIDC.</description><pubDate>Thu, 27 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;A pipeline that publishes to production needs credentials: a cloud provider token, an SSH key, a database password. They are the keys to the house, handed to a machine that works on its own every time the code changes.&lt;/p&gt;
&lt;p&gt;How those keys are stored is the most delicate part of the whole setup, and the part most often got wrong. Not out of ignorance: it goes wrong in a hurry, on a Friday, when the release has to go out and the short way works immediately. A token pasted into a config file does exactly its job, and nobody notices until it is too late.&lt;/p&gt;
&lt;p&gt;Let us look at where they really belong, what to do when one has already leaked, and what is today the best answer: having no keys to store at all.&lt;/p&gt;
&lt;h2&gt;A secret in the repository cannot be deleted&lt;/h2&gt;
&lt;p&gt;The first rule is that a credential never goes into a versioned file. The reason is not obvious: the problem is not the file, it is the &lt;strong&gt;history&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;Git keeps every previous version of every file. If you write a token into a file and delete it tomorrow, today&apos;s file is clean, but yesterday&apos;s commit still contains the credential, readable by anyone with access to the repository, forever. Whoever arrives six months later does not even have to look for it: scrolling the changes is enough.&lt;/p&gt;
&lt;p&gt;From this follows something that surprises people every time: &lt;strong&gt;deleting the secret solves nothing&lt;/strong&gt;. If a credential has landed in a repository, that credential must be treated as compromised and &lt;strong&gt;replaced&lt;/strong&gt;, meaning revoked at the service that issued it and generated again. Rewriting history is possible, with tools made for it, but it is an invasive operation that breaks everyone&apos;s clones and still gives you no guarantee about who has already read it.&lt;/p&gt;
&lt;p&gt;If the repository is public, there is even less time: programs watch GitHub pushes in real time looking for credentials, and the gap between publishing and abuse is measured in minutes. GitHub itself scans public code for known key formats and notifies the provider that issued them, which often revokes them on the spot. That is a safety net, not a solution.&lt;/p&gt;
&lt;h2&gt;The right place: the CI system&apos;s store&lt;/h2&gt;
&lt;p&gt;Every &lt;a href=&quot;/en/changelog/what-is-a-ci-cd-pipeline&quot;&gt;CI/CD pipeline&lt;/a&gt; system has somewhere to keep credentials outside the code: &lt;em&gt;secrets&lt;/em&gt; on GitHub Actions, &lt;em&gt;CI/CD variables&lt;/em&gt; on GitLab. The value is entered once from the interface, and the pipeline only uses the name:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;- run: ./deploy.sh
  env:
    DEPLOY_TOKEN: ${{ secrets.DEPLOY_TOKEN }}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Whoever reads the file sees &lt;code&gt;DEPLOY_TOKEN&lt;/code&gt;, not its value. But putting them there is not enough: two settings matter, and almost nobody looks for them.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Masking&lt;/strong&gt; keeps the value out of job logs. Without it, a command that prints the environment, or a slightly talkative error from a program, is enough to leave the credential in plain text in a log that is usually readable by far more people than can see the settings page.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Restriction to protected branches&lt;/strong&gt; decides which runs receive the secret. It is the most important protection and the least used: without it, anyone who can create a branch in the project can write a three-line pipeline that prints the token and read it at leisure. If the secret is reserved to the main branch, and the main branch only accepts reviewed changes, that road is closed.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Can you say which credentials are sitting in your repositories today?&quot; text=&quot;We audit repositories and pipelines: what is exposed, what must be rotated now, what belongs somewhere else entirely.&quot; button=&quot;Ask for an audit →&quot;}&lt;/p&gt;
&lt;h2&gt;The step up: no key to store at all&lt;/h2&gt;
&lt;p&gt;The best protection for a key is not having one. For a few years now the common CI systems have been able to authenticate to a provider without permanent credentials, through a mechanism called &lt;strong&gt;OIDC&lt;/strong&gt; (&lt;em&gt;OpenID Connect&lt;/em&gt;).&lt;/p&gt;
&lt;p&gt;It works like this. At run time the CI system issues a signed document stating who is asking: this repository, this branch, this run. The pipeline presents it to the cloud provider, which verifies it and, if it matches a rule configured in advance, returns &lt;strong&gt;short-lived&lt;/strong&gt; credentials valid for a few minutes.&lt;/p&gt;
&lt;p&gt;On GitHub Actions it is two blocks:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;permissions:
  id-token: write     # the pipeline may request the identity document
  contents: read

steps:
  - uses: aws-actions/configure-aws-credentials@v4
    with:
      role-to-assume: arn:aws:iam::123456789012:role/deploy-site
      aws-region: eu-south-1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;There is no key anywhere. The &lt;code&gt;deploy-site&lt;/code&gt; role, on the provider side, is configured to trust only that repository and only that branch: another project making the same request is refused.&lt;/p&gt;
&lt;p&gt;The gain is substantial. There is nothing to steal, because the credentials last as long as the run. There is nothing to rotate every six months, and therefore nothing that expires on a Friday afternoon. And trust is tied to a verifiable identity rather than to possession of a string, which is the difference between an ID document and a key found on the pavement. It is worth adopting as soon as your provider supports it, and today the major ones do.&lt;/p&gt;
&lt;h2&gt;Least privilege, identities included&lt;/h2&gt;
&lt;p&gt;Key or short-lived identity, one question remains: how much can that credential do? The correct answer is &lt;strong&gt;the bare minimum&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;A token that publishes a website should be able to publish that website. Not administer the account, not read the other applications, not touch DNS. It is a difference you only feel on the day of the incident, and that day decides whether the damage is &quot;they republished the site&quot; or &quot;they own everything&quot;.&lt;/p&gt;
&lt;p&gt;The same reasoning applies inside the pipeline. On GitHub Actions the &lt;code&gt;permissions&lt;/code&gt; block limits what a run can do to the repository itself: declaring it explicitly, instead of leaving the defaults, keeps a script running in the pipeline from writing where it should not. The principle is the same one that applies to &lt;a href=&quot;/en/changelog/bastion-host&quot;&gt;administrative access to servers&lt;/a&gt; or &lt;a href=&quot;/en/changelog/oauth-security-bcp&quot;&gt;an OAuth authorisation&lt;/a&gt;: a permission granted &quot;for convenience&quot; is a permission that sooner or later someone else will use.&lt;/p&gt;
&lt;h2&gt;The three traps we see most often&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Change proposals from strangers.&lt;/strong&gt; If the project accepts outside contributions, a pipeline triggered by a proposed change runs code written by whoever sent it. GitHub has a trigger, &lt;code&gt;pull_request_target&lt;/code&gt;, that runs with the target repository&apos;s permissions: using it together with a checkout of the proposed code means handing your secrets to a stranger. It is one of the most exploited misconfigurations there is.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Dependencies.&lt;/strong&gt; The pipeline installs libraries, and installing them means running someone else&apos;s code on a machine holding production credentials. A compromised package, as in &lt;a href=&quot;/en/changelog/npm-supply-chain-cooldown&quot;&gt;every npm episode of the past year&lt;/a&gt;, reads the environment variables and ships them out. Practical defences: block install scripts, freeze versions, and do not hand secrets to stages that are not publishing. Whoever runs the tests does not need the production token.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Logs.&lt;/strong&gt; A command run with the variable inline, a &lt;code&gt;curl -v&lt;/code&gt; printing headers, an error echoing the full URL with the token in it: job logs are often where the secret escapes, and also the place nobody thinks to check.&lt;/p&gt;
&lt;h2&gt;If a secret has already leaked&lt;/h2&gt;
&lt;p&gt;In order, skipping nothing. &lt;strong&gt;Revoke it immediately&lt;/strong&gt; at the service that issued it: it is the only action that actually stops the bleeding, and it comes before everything else. &lt;strong&gt;Generate a new one&lt;/strong&gt;, with the minimum permissions genuinely required, and put it in the CI system&apos;s store. &lt;strong&gt;Check what was done&lt;/strong&gt; with the old one, looking at the provider&apos;s access logs for the preceding hours. Only at the end, if it still matters, clean up the file.&lt;/p&gt;
&lt;p&gt;Once that is settled, it pays to add a net: there are tools that scan code for credentials and can run automatically before every commit, so the next key pasted in a hurry is stopped on the spot instead of discovered six months later.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Pipeline secrets do not belong in the repository, because Git history does not forget and a credential that lands there must be considered burnt: revoke and regenerate, do not delete. They belong in the CI system&apos;s store, with masking in the logs and restriction to protected branches, which is what stops any random branch from reading them. Better still, do not store them at all: with OIDC the pipeline proves who it is and receives credentials that last minutes, so there is nothing to steal and nothing to rotate. Above all sits least privilege, which is what decides whether an incident is a nuisance or a disaster.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want production to be published by a short-lived identity, not an eternal key?&quot; text=&quot;We review the pipelines you already have: credentials moved out of the code, permissions cut to the minimum and, where the provider allows it, a move to OIDC with no keys left to store.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.github.com/en/actions/security-for-github-actions/security-guides/security-hardening-for-github-actions&quot;&gt;Security hardening for GitHub Actions&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.github.com/en/actions/security-for-github-actions/security-hardening-your-deployments/about-security-hardening-with-openid-connect&quot;&gt;OpenID Connect in GitHub Actions&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.gitlab.com/ee/ci/variables/#cicd-variable-security&quot;&gt;GitLab, CI/CD variable security&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://owasp.org/www-project-top-10-ci-cd-security-risks/&quot;&gt;OWASP Top 10 CI/CD Security Risks&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Proxmox VE 8 end of life: why upgrade now and what changes in version 9</title><link>https://initd.it/en/changelog/proxmox-8-end-of-life-upgrade</link><guid isPermaLink="true">https://initd.it/en/changelog/proxmox-8-end-of-life-upgrade</guid><description>On 31 August 2026 Proxmox VE 8 leaves support: no more security fixes for kernel, QEMU and the cluster stack. What you risk by staying, what breaks in version 9 and how to upgrade without downtime.</description><pubDate>Sun, 23 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;If your company has a server running virtual machines, there is a good chance it runs &lt;strong&gt;Proxmox VE 8&lt;/strong&gt;: released in June 2023, it was the version everyone installed for three years. On 31 August 2026 it leaves support. From that day on Proxmox publishes no more fixes for version 8, neither for bugs nor for security holes. The web interface of version 8 has been showing a notice in the top bar for a while now, with the exact date.&lt;/p&gt;
&lt;p&gt;Nothing visible happens. Servers stay on, virtual machines keep running, no counter expires. That is precisely the problem: a &lt;strong&gt;hypervisor&lt;/strong&gt; (the software that runs virtual machines on a physical server) sits underneath everything else, and when it stops receiving patches the risk quietly moves onto every service it hosts.&lt;/p&gt;
&lt;p&gt;Below: what end of support means in practice, what you risk by staying on 8, what breaks when moving to 9 and how to handle the upgrade without stopping the business. Everything comes from official Proxmox sources, linked at the bottom.&lt;/p&gt;
&lt;h2&gt;End of support: what it means for a hypervisor&lt;/h2&gt;
&lt;p&gt;Proxmox&apos;s rule is public: every Proxmox VE version is supported &lt;strong&gt;at least as long as the Debian release it is built on is supported by the Debian security team&lt;/strong&gt;, that is roughly three years from first release. Proxmox VE 8 is built on Debian 12 &quot;Bookworm&quot;, whose regular security support ended in mid 2026, and the official lifecycle table sets the end of support for Proxmox VE 8 at August 2026. The last update of the 8 branch, version 8.4.21, is dated 14 August.&lt;/p&gt;
&lt;p&gt;One detail that creates confusion: Debian 12 now moves to &lt;strong&gt;LTS&lt;/strong&gt; support, run by a separate group of volunteers and companies, until mid 2028. That support covers Debian packages, not Proxmox. The kernel, QEMU (the engine behind the virtual machines), LXC (containers), ZFS and the whole cluster management layer are packages maintained by Proxmox, and in version 8 they are no longer maintained. Relying on Debian LTS for an end-of-life hypervisor is a misunderstanding.&lt;/p&gt;
&lt;p&gt;It is the same mechanism we described for &lt;a href=&quot;/en/changelog/php-end-of-life-risks&quot;&gt;PHP at end of life&lt;/a&gt;: the software does not stop working, it stops being defended. Only here the exposed surface is not a website, it is the whole server.&lt;/p&gt;
&lt;h2&gt;What you risk by staying on 8&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Vulnerabilities with no fix.&lt;/strong&gt; Flaws keep being discovered after support ends: only the distribution of fixes stops. Even in 2026 the 8.4 branch kept receiving security-relevant updates: in April the authentication of VNC and SPICE consoles was hardened, in August the privileges required to abort backups were tightened and some interface fields were protected from unfiltered content. From September, fixes of this kind no longer reach version 8. And a hole in the hypervisor is worth as much as a hole in every machine it hosts.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;The ecosystem moves on.&lt;/strong&gt; Proxmox Backup Server is already at version 4, the latest Ceph release (the integrated distributed storage) is only available from 9.2, third-party storage plugins are being adapted to 9. Support for new hardware arrives with recent kernels: Proxmox VE 9.2 ships kernel 7.0, version 8 stays on 6.8 (6.14 as an option). Whoever buys a server today and installs 8 on it may find that network cards or controllers are not recognized.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;No shortcut later.&lt;/strong&gt; Proxmox documents and supports only the step from one major version to the next: from 7 you go through 8, from 8 you reach 9, and the jump gets longer with every year you wait.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Compliance.&lt;/strong&gt; For anyone processing personal data the GDPR asks for measures &quot;appropriate to the state of the art&quot;: as we saw when discussing &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR from the infrastructure side&lt;/a&gt;, a component abandoned by its vendor is hard to defend as appropriate, and in case of an incident the hypervisor version ends up in the report.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Not sure how many Proxmox 8 hosts you run, or whether they are ready for 9?&quot; text=&quot;We do the inventory for you: version, storage, old containers, hardware, backups. We tell you what can be upgraded right away and what needs preparing first.&quot; button=&quot;Ask for a check →&quot;}&lt;/p&gt;
&lt;h2&gt;What Proxmox VE 9 brings&lt;/h2&gt;
&lt;p&gt;Upgrading is not just removing a risk. Proxmox VE 9 came out in August 2025 on Debian 13 &quot;Trixie&quot; and is already at its third release (9.2, May 2026): a platform proven for a year, not a novelty to wait for.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Snapshots on shared thick-provisioned LVM storage&lt;/strong&gt;, the typical setup of SANs over iSCSI or Fibre Channel: it was impossible before, now it works through volume chains (a technology preview, but it covers a very common case in small businesses with network storage). If those volumes are new to you, we explained &lt;a href=&quot;/en/changelog/lvm-storage&quot;&gt;what LVM is and how it manages disks&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Affinity rules for high availability&lt;/strong&gt;: you declare that certain VMs must stay on certain nodes, or that two VMs must never land on the same node. With 9.2 comes &lt;strong&gt;dynamic load balancing&lt;/strong&gt;, which moves VMs on its own from the busiest node to the least busy one.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;ZFS 2.3&lt;/strong&gt; (2.4 in 9.2), which allows adding a disk to an existing RAID-Z without rebuilding it from scratch.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;SDN fabrics&lt;/strong&gt; (OpenFabric and OSPF, WireGuard and BGP from 9.2) to connect nodes with routed networks instead of hand-configured crossed cables: useful for full-mesh Ceph clusters.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Containers from OCI images&lt;/strong&gt; (from 9.1): the same formats used for Docker become templates for LXC containers.&lt;/li&gt;
&lt;li&gt;Updated kernel, QEMU and LXC (kernel 6.14 in 9.0 and 7.0 in 9.2, QEMU 10 then 11) and a new mobile interface.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;What breaks: the backward incompatibilities&lt;/h2&gt;
&lt;p&gt;This is the part the official guide calls &lt;em&gt;breaking changes&lt;/em&gt;, and it must be read before, not after. Translated into concrete situations:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Old containers.&lt;/strong&gt; Version 9 drops support for &lt;em&gt;cgroup v1&lt;/em&gt;, the old mechanism the kernel uses to assign resources to containers. Consequence: containers whose operating system is based on systemd version 230 or older (from 2016) &lt;strong&gt;no longer start&lt;/strong&gt;. The examples Proxmox cites are CentOS 7 and Ubuntu 16.04. If you have any, the operating system inside the container must be migrated before upgrading the host, not after.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Network interface names can change&lt;/strong&gt; with the new kernel, and if the configuration points to the old name the server comes back up without network. Proxmox provides a tool to pin the names before upgrading (&lt;code&gt;pve-network-interface-pinning&lt;/code&gt;) and recommends an access path independent of the network (IPMI, iKVM or a physical console) so nobody has to rush to the server room.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Storage.&lt;/strong&gt; GlusterFS is no longer supported: data must be moved elsewhere. Third-party storage plugins only work if their author adapted them to 9. On shared LVM volumes the official script that disables volume autoactivation must be run, to prevent several nodes from activating the same disks.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Old hardware.&lt;/strong&gt; Proxmox states that hardware older than ten years is not thoroughly tested with the new kernel, cites AMD Opteron and Turion CPUs from 2009-2010 on which Ceph stops with an illegal instruction error, and reports that in some cases PCI &lt;em&gt;passthrough&lt;/em&gt; (for example a GPU assigned to a VM) does not start with kernel 6.14. NVIDIA vGPU cards need at least the GRID 18.3 driver.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Third-party backup.&lt;/strong&gt; Veeam does not work with VMs using QEMU machine version 10 or later; the workaround is pinning the machine version to 9.2 until Veeam catches up. Anyone running Proxmox Backup Server on the same machine must upgrade that too, to version 4, following its dedicated guide.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;System details that do not forgive.&lt;/strong&gt; The file &lt;code&gt;/etc/sysctl.conf&lt;/code&gt; is no longer read (settings go into &lt;code&gt;/etc/sysctl.d/&lt;/code&gt;), &lt;code&gt;/tmp&lt;/code&gt; becomes an in-memory folder cleaned periodically, some permissions change (the &lt;code&gt;VM.Monitor&lt;/code&gt; privilege disappears, &lt;code&gt;VM.Replicate&lt;/code&gt; appears, creating privileged containers requires &lt;code&gt;Sys.Modify&lt;/code&gt;), the &lt;code&gt;maxfiles&lt;/code&gt; backup option is removed, VirtIO network cards without an explicit MTU inherit the bridge&apos;s instead of 1500. Nothing dramatic, but all of it must be known in advance.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The point is not to scare: each of these items either does not concern you or gets solved before starting, and the difference is made by having checked them.&lt;/p&gt;
&lt;h2&gt;How to upgrade without stopping the business&lt;/h2&gt;
&lt;p&gt;Proxmox provides an official step-by-step guide and a tool, &lt;code&gt;pve8to9&lt;/code&gt;, that checks the host and flags in advance everything listed above. The method we follow:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Inventory.&lt;/strong&gt; How many hosts, which version (at least 8.4.1 is required), which storage, which Ceph (it must already be Squid 19.2), which containers and with which operating system, which hardware and from which year.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;pve8to9 --full&lt;/code&gt; checklist&lt;/strong&gt; on every node, fixing every warning before moving on. The tool only checks, it corrects nothing on its own.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Safety net.&lt;/strong&gt; Verified backups of all VMs and containers following the &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;3-2-1 rule&lt;/a&gt;, a copy of the &lt;code&gt;/etc&lt;/code&gt; configuration, out-of-band access to the server and at least 5 GB free on the system partition.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;One node at a time.&lt;/strong&gt; In a cluster you move the VMs to the other nodes with live migration, upgrade the empty node, reboot, verify, move to the next: services never stop. On a single host you need a maintenance window: the &lt;code&gt;apt dist-upgrade&lt;/code&gt; alone takes from under five minutes on SSDs to over an hour on spinning disks, plus the reboot.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Final check.&lt;/strong&gt; Reboot into the new kernel, check network and storage, automatic migration of HA groups into rules, browser cache cleared for the new interface, repositories moved to the new format.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;For a clean install (for example on new hardware) there is also the reinstall-from-ISO path with VMs restored from backups: often the fastest route when you change server together with the version.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Proxmox VE 8 does not switch off on 31 August 2026, but from that day every new flaw stays open on the server that holds all your virtual machines, and Debian LTS does not cover the Proxmox components. Version 9 has been mature for a year, brings snapshots on shared storage, smarter high availability and support for recent hardware, and the upgrade is a documented path: the delicate part is the incompatibilities (old containers, network names, storage, old hardware, third-party backup), all of which are found before starting with an inventory and the official checklist.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Running Proxmox 8 hosts in production and want to move to 9 without surprises?&quot; text=&quot;We plan and carry out the upgrade: host inventory, pve8to9 checklist, verified backup, live migration of VMs in clusters, agreed window on single hosts and guaranteed rollback. We manage Linux and Proxmox servers for SMEs and agencies.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://pve.proxmox.com/wiki/FAQ#faq-support-table&quot;&gt;Proxmox VE FAQ, version lifecycle table&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://pve.proxmox.com/wiki/Upgrade_from_8_to_9&quot;&gt;Upgrade from 8 to 9, official guide with prerequisites and known issues&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://pve.proxmox.com/wiki/Roadmap&quot;&gt;Proxmox VE Roadmap, release notes 9.0, 9.1 and 9.2 with breaking changes&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://wiki.debian.org/LTS&quot;&gt;Debian LTS, schedule and scope of long term support&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://git.proxmox.com/?p=pve-manager.git;a=blob_plain;f=debian/changelog;hb=refs/heads/stable-8&quot;&gt;pve-manager changelog, stable-8 branch (latest 8.4.x releases)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>What a CI/CD pipeline is (and why manual deployment costs more than it looks)</title><link>https://initd.it/en/changelog/what-is-a-ci-cd-pipeline</link><guid isPermaLink="true">https://initd.it/en/changelog/what-is-a-ci-cd-pipeline</guid><description>What a CI/CD pipeline is, explained simply: continuous integration, continuous delivery, working examples with GitHub Actions and GitLab CI, and what is worth putting inside one.</description><pubDate>Thu, 20 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;In a lot of companies, releasing a website or an application is still a manual gesture. Someone opens a terminal, runs a sequence of commands learned by heart, waits, reloads the page and hopes. If the site shows up, everyone moves on. If it does not, the hunt begins: what changed, who touched what, how it looked before.&lt;/p&gt;
&lt;p&gt;The problem is not the skill of the person typing. The problem is that a manual release is an unwritten procedure: slightly different every time, impossible to review beforehand, and tied to one person. When that person is on holiday, in a hurry or changes job, releasing becomes a risk.&lt;/p&gt;
&lt;p&gt;A &lt;strong&gt;CI/CD pipeline&lt;/strong&gt; answers that problem. It is the idea of writing down, once, what must happen when the code changes, and letting a machine do it the same way every time, checking before publishing.&lt;/p&gt;
&lt;h2&gt;Continuous integration: someone else checks your code&lt;/h2&gt;
&lt;p&gt;The first half of the acronym is &lt;strong&gt;CI&lt;/strong&gt;, continuous integration. The idea is simple: every time someone saves work to the shared repository, a neutral machine downloads the project &lt;strong&gt;from scratch&lt;/strong&gt;, installs everything it needs and runs the checks.&lt;/p&gt;
&lt;p&gt;That &quot;from scratch&quot; is the part that matters. On a developer&apos;s laptop the project also works thanks to things installed months ago and forgotten: a system library, an environment variable, a config file that was never committed. The CI machine has no such memory. If the project works there, it really works, and the industry&apos;s favourite sentence, &quot;it works on my machine&quot;, stops being an opinion.&lt;/p&gt;
&lt;p&gt;The practical benefit is &lt;em&gt;when&lt;/em&gt; you find out. A test failing two minutes after you save costs five minutes, because you still remember what you were doing. The same failure found in production three weeks later costs a day, plus the phone call from the client.&lt;/p&gt;
&lt;h2&gt;Continuous delivery: from checked code to a live site&lt;/h2&gt;
&lt;p&gt;The second half is &lt;strong&gt;CD&lt;/strong&gt;, and it is worth separating two meanings that often get mixed up.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Continuous delivery&lt;/em&gt; means the verified code is &lt;strong&gt;always ready&lt;/strong&gt; to go to production, and publishing happens when somebody presses a button. &lt;em&gt;Continuous deployment&lt;/em&gt; goes further: if every check passes, publishing happens &lt;strong&gt;on its own&lt;/strong&gt;, with no human involved.&lt;/p&gt;
&lt;p&gt;These are not skill levels, they are different choices: an online shop releasing twenty times a day benefits from automatic deployment, a firm updating a client&apos;s management software once a month lives perfectly well with the button. When starting out, the button is the sensible default: you get almost all the value and keep control over &lt;em&gt;when&lt;/em&gt; things change.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your production release depend on who remembers the commands?&quot; text=&quot;We write the procedure down, hand it to a machine, and add a verification step before anything goes live.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;What a pipeline actually looks like&lt;/h2&gt;
&lt;p&gt;A pipeline is a text file, versioned alongside the code, describing the steps to run. Here is the minimal version with &lt;strong&gt;GitHub Actions&lt;/strong&gt;, one of the most common systems:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;name: CI
on: push

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - run: npm ci
      - run: npm test
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In plain English: on every push, start a clean Linux machine, download the code, install Node 22, install dependencies exactly as recorded in the lock file (&lt;code&gt;npm ci&lt;/code&gt;, not &lt;code&gt;npm install&lt;/code&gt;) and run the tests. If any command fails, the pipeline turns red and whoever made the change gets notified.&lt;/p&gt;
&lt;p&gt;Pinning the Node version is not pedantry: it is the same reason it pays to &lt;a href=&quot;/en/changelog/pnpm-node-version&quot;&gt;declare the runtime version in the project&lt;/a&gt;. A pipeline that uses &quot;the latest available version&quot; will one day break on its own, with nobody having touched anything.&lt;/p&gt;
&lt;p&gt;From there you grow it by adding publishing, which only runs if the tests passed and only from the main branch:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;  deploy:
    needs: test
    if: github.ref == &apos;refs/heads/main&apos;
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci &amp;amp;&amp;amp; npm run build
      - run: ./deploy.sh
        env:
          DEPLOY_TOKEN: ${{ secrets.DEPLOY_TOKEN }}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The two lines that matter are &lt;code&gt;needs: test&lt;/code&gt;, which prevents unverified code from being published, and &lt;code&gt;if:&lt;/code&gt;, which limits publishing to the main branch: work on a side branch gets checked but never goes live.&lt;/p&gt;
&lt;h2&gt;Same idea, different systems&lt;/h2&gt;
&lt;p&gt;The way you write it changes, the idea does not. The same pipeline on &lt;strong&gt;GitLab CI&lt;/strong&gt; looks like this:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;stages:
  - test
  - deploy

test:
  image: node:22
  script:
    - npm ci
    - npm test

deploy:
  stage: deploy
  only:
    - main
  when: manual
  script:
    - ./deploy.sh
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Here &lt;code&gt;when: manual&lt;/code&gt; is the button described above: the work is prepared automatically, a person decides when it goes out. Forgejo and Gitea, which host code on your own servers, use a syntax nearly identical to GitHub Actions, and veterans like Jenkins have been doing this for twenty years. Picking the tool matters far less than deciding to have a written procedure at all.&lt;/p&gt;
&lt;p&gt;One term to know: the machine running the steps is called a &lt;em&gt;runner&lt;/em&gt;. It can be provided by the service, where you pay per minute, or be a machine of yours if the code must not leave the company network. In the second case it has to be installed, updated and isolated, because it executes code on every change to the project.&lt;/p&gt;
&lt;h2&gt;What is worth putting inside&lt;/h2&gt;
&lt;p&gt;The right order of steps goes from fastest to slowest, so a trivial mistake does not keep you waiting ten minutes to hear about it:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Formal checks&lt;/strong&gt;: formatting and static analysis, a few seconds.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Automated tests&lt;/strong&gt;: the core of the verification.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Build&lt;/strong&gt;: if the project does not compile, there is no point going further.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Project specific checks&lt;/strong&gt;: this is the part almost nobody exploits.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Publishing&lt;/strong&gt;.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Point 4 deserves an example, because it is where a pipeline stops being generic and becomes yours. A check is simply a command that exits with zero when all is well and something else when it is not:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;#!/usr/bin/env bash
set -euo pipefail

if grep -rn &quot;console.log&quot; src/; then
  echo &quot;Leftover debug calls found in src/&quot;
  exit 1
fi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The same logic verifies things that are not code at all: oversized images committed by mistake, internal links pointing at pages that no longer exist, translation files out of sync between two languages, editorial rules for a blog. These are the errors nobody catches by re-reading, and a machine catches every time.&lt;/p&gt;
&lt;h2&gt;Secrets, the part most often got wrong&lt;/h2&gt;
&lt;p&gt;Publishing needs credentials: a provider token, an SSH key, a database password. Three rules, in order of importance.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Never in the repository.&lt;/strong&gt; A token written into a versioned file stays in the history even after you delete it: removing it from the file does not remove it from earlier commits. When it happens, the only serious answer is to rotate that token. The topic is dense enough to deserve its own article, where we go into detail on &lt;a href=&quot;/en/changelog/pipeline-secrets&quot;&gt;where pipeline secrets actually belong&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;In the CI system, with the protections on.&lt;/strong&gt; The two settings to look for are &lt;em&gt;masking&lt;/em&gt;, which stops the credential from appearing in job logs, and restriction to protected branches. Without those, the token is readable by anyone who can edit the pipeline file.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;With least privilege.&lt;/strong&gt; The token that publishes the site should be able to publish the site, not administer the whole account.&lt;/p&gt;
&lt;p&gt;There is one last aspect people tend to ignore: a pipeline installs dependencies, and installing dependencies means &lt;strong&gt;running code written by strangers&lt;/strong&gt; on a machine holding production credentials. That is why it pays to understand &lt;a href=&quot;/en/changelog/npm-supply-chain-cooldown&quot;&gt;what happens when a package is compromised&lt;/a&gt;, and why the runner should be isolated from the rest of the infrastructure.&lt;/p&gt;
&lt;h2&gt;What it costs, honestly&lt;/h2&gt;
&lt;p&gt;A pipeline is not free: it has to be written, maintained, and every so often it breaks by itself because a token expires or a version changes. On tiny projects, with a single developer and a release every six months, it may not be worth it.&lt;/p&gt;
&lt;p&gt;Then there is a cultural risk, and it is the serious one: &lt;strong&gt;a pipeline that has been red for weeks is not a pipeline, it is a broken traffic light&lt;/strong&gt;. Once red becomes normal, people learn to ignore it and the checks stop meaning anything. Green must be the ordinary state: when a check produces too many false alarms, either fix it or remove it, but do not leave it blinking.&lt;/p&gt;
&lt;p&gt;Finally, a pipeline verifies only what you told it to verify. It does not replace a restore you have &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;actually tested&lt;/a&gt;, nor the ability to go back quickly when something slips through anyway.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;A CI/CD pipeline turns releasing from a memorised procedure into an executable document: continuous integration checks every change on a clean machine, continuous delivery takes what passed to production, with or without a button in between. It lives in a text file versioned with the code and works the same way on GitHub Actions, GitLab CI or a self-hosted system. As with &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;infrastructure described in text files&lt;/a&gt;, the real gain is not speed: it is no longer entrusting to one person something the company does every week.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want your software to go live only when the checks pass?&quot; text=&quot;We design and maintain pipelines on GitHub Actions, GitLab CI and self-hosted runners, for custom applications, websites and cloud services. That includes credential handling and a tested way to roll back fast.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.github.com/en/actions&quot;&gt;GitHub Actions, official documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.gitlab.com/ee/ci/&quot;&gt;GitLab CI/CD, official documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://martinfowler.com/articles/continuousIntegration.html&quot;&gt;Continuous Integration, Martin Fowler&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://dora.dev/research/&quot;&gt;DORA, research on software delivery metrics&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>OpenTofu: the Terraform Alternative After the License Change</title><link>https://initd.it/en/changelog/opentofu-terraform-alternative</link><guid isPermaLink="true">https://initd.it/en/changelog/opentofu-terraform-alternative</guid><description>In 2023 Terraform changed its license and the community created OpenTofu, an open source fork under the Linux Foundation. What it means, when to switch, and how to avoid lock-in.</description><pubDate>Thu, 13 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Imagine building your house under a town&apos;s rules. One day the town changes the building code, and things you used to do freely now need a permit, or are no longer allowed. The house is already up, but the rules of the game changed after the work was done. That is roughly what happened in 2023 to anyone using &lt;strong&gt;Terraform&lt;/strong&gt;, the most widely adopted tool for &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;infrastructure as code&lt;/a&gt;, the practice of managing servers, networks and firewalls by writing them in text files instead of configuring them by hand.&lt;/p&gt;
&lt;p&gt;The company behind Terraform, HashiCorp, changed the product&apos;s license, making it more restrictive. In response, part of the community that used and contributed to Terraform created an independent, derived version called &lt;strong&gt;OpenTofu&lt;/strong&gt;, now maintained as a neutral open source project. For anyone who manages infrastructure, or relies on someone who does, understanding this story serves a concrete purpose: knowing what your work rests on, and what alternatives exist.&lt;/p&gt;
&lt;h2&gt;What happened to Terraform&apos;s license&lt;/h2&gt;
&lt;p&gt;Until August 2023 Terraform shipped under a genuine &lt;strong&gt;open source&lt;/strong&gt; license, the MPL 2.0: anyone could use, modify and redistribute it without particular constraints. Then HashiCorp moved to the &lt;strong&gt;Business Source License&lt;/strong&gt; (BSL), a license described as &lt;em&gt;source-available&lt;/em&gt;: the code stays visible and usable by almost everyone, but with a catch. You can no longer use Terraform to build a product that competes with HashiCorp itself.&lt;/p&gt;
&lt;p&gt;The difference sounds technical, but the practical point is simple. A recognized &lt;em&gt;open source&lt;/em&gt; license guarantees that nobody, in the future, can change the rules and restrict the use of what you adopted. A &lt;em&gt;source-available&lt;/em&gt; license like the BSL removes that guarantee: the owner decides what is allowed and what is not, and can revisit it. For the vast majority of people using Terraform to manage their own servers nothing changes overnight, but for the ecosystem, meaning the companies and projects built around the tool, the signal was heavy. Those who had invested years in a free technology suddenly faced different rules set by a single company. Shortly afterwards, HashiCorp was acquired by IBM, which made the question even more concrete: who do you trust when you choose the tool that holds up your infrastructure?&lt;/p&gt;
&lt;h2&gt;What OpenTofu is and who governs it&lt;/h2&gt;
&lt;p&gt;Within weeks of the license change, a group of companies and developers announced a &lt;strong&gt;fork&lt;/strong&gt; of Terraform. A fork is a copy of the code that continues on its own path, independent of the original. The project was named OpenTofu and handed not to a single company, but to the &lt;strong&gt;Linux Foundation&lt;/strong&gt;, the same independent foundation that hosts Linux and, more recently, &lt;a href=&quot;/en/changelog/mcp-linux-foundation&quot;&gt;the MCP standard for connecting AI tools to external systems&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;This step is the heart of the story. OpenTofu returned to a recognized open source license (the same MPL 2.0 Terraform had before), and its &lt;strong&gt;governance&lt;/strong&gt;, meaning who decides how it evolves, is no longer in the hands of one company but of a community under a neutral foundation. The benefit is not ideological: it is a contractual guarantee that the license-change story cannot repeat itself. Nobody can later make OpenTofu source-available after the fact, because there is no single owner to decide it. For anyone building on a tool, knowing the rules will not shift under their feet is worth as much as the features.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your infrastructure depend on a third-party tool?&quot; text=&quot;Let&apos;s assess how tied you are to a single technology and which open alternatives cut the risk.&quot; button=&quot;Ask for an assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;Terraform or OpenTofu: what changes in practice&lt;/h2&gt;
&lt;p&gt;The best news for Terraform users is that OpenTofu was born as a &lt;strong&gt;compatible&lt;/strong&gt; replacement. In the early days it behaved like a faithful copy: the same configuration files, the same HCL language, the same &lt;em&gt;providers&lt;/em&gt; (the components that translate the description into calls to the various &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;cloud providers&lt;/a&gt;). The command-line tool only changes in name: you type &lt;code&gt;tofu&lt;/code&gt; instead of &lt;code&gt;terraform&lt;/code&gt;, and in most cases everything else stays the same.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# Before
terraform init
terraform plan
terraform apply

# With OpenTofu, same files and same flow
tofu init
tofu plan
tofu apply
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Over time the two projects began to diverge, each adding its own features. OpenTofu, for instance, introduced &lt;strong&gt;state encryption&lt;/strong&gt;: the state file is the record the tool keeps of what it has already created, and it often holds sensitive information, so being able to encrypt it helps security. Terraform, in turn, follows its own roadmap. This means perfect compatibility mostly holds for those migrating from not-too-recent versions, while anyone using the latest features of either has to check case by case. For a typical project, though, migration stays painless: you point OpenTofu at the existing files and current state, run a preview of the changes, and if no unwanted changes appear you keep working as before.&lt;/p&gt;
&lt;p&gt;When is it worth switching? There is no obligation, and Terraform keeps working perfectly. Choosing OpenTofu makes the most sense when having a &lt;strong&gt;genuinely open source&lt;/strong&gt; technology with neutral governance matters: to avoid &lt;em&gt;lock-in&lt;/em&gt;, meaning dependence on a vendor that can change the terms, for company policy reasons, or simply to stay on a community-driven project. It is the same prudence that applies to every piece of third-party software you depend on, from &lt;a href=&quot;/en/changelog/npm-supply-chain-cooldown&quot;&gt;the packages that end up in your applications&lt;/a&gt; to the tool that governs your servers.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;In 2023 Terraform moved from an open source license to a more restrictive one, and the community responded by creating OpenTofu, a fork back to open source and handed to the Linux Foundation. The day-to-day practical difference for managing infrastructure is minimal, because OpenTofu was born compatible and migration is almost always a change of command. The real difference is in guarantees: with OpenTofu the terms of use do not depend on a single company and cannot change after the fact. Terraform remains the most widely used tool and a valid choice, but it is no longer the only one, and knowing the alternative is the first step to not being tied to a technology you do not control.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want infrastructure that doesn&apos;t depend on a single vendor?&quot; text=&quot;We design and manage infrastructure as code with Terraform and OpenTofu, on AWS, Google Cloud and other providers, with an eye on lock-in and long-term continuity.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://opentofu.org/blog/opentofu-announces-fork-of-terraform/&quot;&gt;OpenTofu Announces Fork of Terraform&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.linuxfoundation.org/press/announcing-opentofu&quot;&gt;OpenTofu joins the Linux Foundation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.hashicorp.com/blog/hashicorp-adopts-business-source-license&quot;&gt;HashiCorp adopts Business Source License&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://opentofu.org/docs/intro/migration/&quot;&gt;OpenTofu - Migrating from Terraform&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Slow PrestaShop: where the problem comes from and how to fix it</title><link>https://initd.it/en/changelog/speed-up-prestashop</link><guid isPermaLink="true">https://initd.it/en/changelog/speed-up-prestashop</guid><description>A slow PrestaShop isn&apos;t fixed by guesswork: you measure, find the bottleneck and act on the right layer, across hosting, PHP, MySQL, modules and caching.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;A slow online store loses sales, and it&apos;s a silent loss: no customer writes in to say the page took too long, they simply close the tab and buy elsewhere. Every extra second of waiting is paid in abandoned carts, and the bill arrives at the worst possible time, when a promotion or a campaign brings more traffic than usual.&lt;/p&gt;
&lt;p&gt;PrestaShop is not a slow platform by itself: it becomes one. Years of &lt;a href=&quot;/en/changelog/prestashop-modules-incompatible-9&quot;&gt;modules installed and never removed&lt;/a&gt;, a theme bought for its looks, hosting chosen when the shop was small, a database grown without maintenance. The good news is that slowness is neither a sentence nor a mystery: it can be diagnosed and cured, as long as you proceed with a method instead of guesswork.&lt;/p&gt;
&lt;h2&gt;Slowness always has an address&lt;/h2&gt;
&lt;p&gt;&quot;The site is slow&quot; is a single symptom, but the causes live in different places: the network and the hosting, the PHP version and its configuration, the MySQL database, the theme and the modules, the front-end with its scripts. Each layer has its own remedies, and working on the wrong layer produces nothing.&lt;/p&gt;
&lt;p&gt;The most common mistake is exactly that: moving to more expensive hosting without knowing where the time is lost. If the bottleneck is a module running hundreds of queries to build the home page, doubling the server&apos;s RAM changes little: the bill goes up, the waiting stays.&lt;/p&gt;
&lt;h2&gt;Measure before you touch anything&lt;/h2&gt;
&lt;p&gt;Diagnosis separates two families of time. There is the time the server takes to generate the page, visible in the &lt;a href=&quot;/en/changelog/ttfb-explained&quot;&gt;TTFB, the Time To First Byte&lt;/a&gt;, and the time the browser takes to make it usable, measured by the &lt;a href=&quot;/en/changelog/inp-core-web-vital&quot;&gt;Core Web Vitals&lt;/a&gt;. A high TTFB points to server, PHP, database or caching; a good TTFB with a sluggish page points to theme, images and scripts.&lt;/p&gt;
&lt;p&gt;The tools are already there. PageSpeed Insights frames the front-end. On the server side, PrestaShop ships with a built-in profiler: turn it on and you see, page by page, how much time goes to PHP, how many queries run and which ones cost the most. On the database, MySQL&apos;s &lt;em&gt;slow query log&lt;/em&gt; records every statement over a threshold. A concrete example: if the home page answers in 1.8 seconds and the profiler shows 900 queries, the problem is not the image slider, it&apos;s whoever builds that page.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your PrestaShop slow down exactly when it sells the most?&quot; text=&quot;We run the diagnosis for you: we measure TTFB, queries and modules, find the bottleneck and tell you what is worth fixing, before touching anything.&quot; button=&quot;Ask for a free assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;Server side: PHP, OPcache and MySQL&lt;/h2&gt;
&lt;p&gt;PrestaShop is a PHP application, and the PHP version matters: every recent release runs the same code faster than the previous one, and old versions, besides being slow, &lt;a href=&quot;/en/changelog/php-end-of-life-risks&quot;&gt;no longer receive security fixes&lt;/a&gt;. Next to the version you need &lt;strong&gt;OPcache&lt;/strong&gt;, the extension that keeps compiled code in memory instead of recompiling it on every request:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;; /etc/php/8.3/fpm/conf.d/10-opcache.ini
opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=40000
; in production: no file checks on every request,
; the cache is flushed at deploy time
opcache.validate_timestamps=0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;On the database side, MySQL&apos;s golden rule is an &lt;strong&gt;InnoDB buffer pool&lt;/strong&gt; sized so that the shop&apos;s hot data fits in memory: if the buffer is too small, every product page pays disk reads that could be avoided. The picture is completed by a PHP-FPM pool proportioned to the available CPU and RAM and by an active slow query log, so problem queries are seen rather than suspected.&lt;/p&gt;
&lt;h2&gt;Modules and theme: the usual suspects&lt;/h2&gt;
&lt;p&gt;Every installed module adds hooks that fire on each page, extra queries, sometimes calls to external services that hold the response hostage. The marketplace is full of well-written modules and badly written ones, and a single bad one is enough: the classic defect is a query repeated for every product in a listing instead of one query for the whole listing.&lt;/p&gt;
&lt;p&gt;The cure is unglamorous but effective: an inventory of the modules, disabling the unused ones and the duplicates, and for the suspects the acid test, disable and measure again. The same goes for the theme, where &lt;em&gt;overrides&lt;/em&gt; accumulated over the years can rewrite pieces of the platform less efficiently than the original.&lt;/p&gt;
&lt;h2&gt;The right cache in the right place&lt;/h2&gt;
&lt;p&gt;Caching in a PrestaShop works in layers: the Smarty template cache, the platform&apos;s internal cache, a &lt;em&gt;full page cache&lt;/em&gt; in front of everything for pages that are identical for all visitors, ideally served by &lt;a href=&quot;/en/changelog/nginx-reverse-proxy&quot;&gt;a reverse proxy&lt;/a&gt;, and a CDN for images and static assets.&lt;/p&gt;
&lt;p&gt;Two warnings. First: a cache hides slow code, it does not repair it, and cart, checkout and account areas stay dynamic by nature, so a healthy backend is needed anyway. Second: a badly configured cache does worse damage than slowness, from an outdated price shown to a customer to another user&apos;s cart. It has to be designed, not merely switched on.&lt;/p&gt;
&lt;h2&gt;Hosting matters, but it&apos;s not always to blame&lt;/h2&gt;
&lt;p&gt;On shared hosting resources are split with the neighbours: CPU, disk and database can slow down through no fault of yours, and the limits show as soon as the shop grows. Moving to a VPS or to cloud sized on real traffic is often the turning point, and &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;choosing the provider&lt;/a&gt; deserves the same criteria as any serious infrastructure.&lt;/p&gt;
&lt;p&gt;The right order of things still stands, though: more powerful hardware applied to a shop with 900 queries on the home page is an elegant way to pay more for the same problem. Diagnosis first, sizing second.&lt;/p&gt;
&lt;h2&gt;In summary&lt;/h2&gt;
&lt;p&gt;A slow PrestaShop is tackled in sequence: measure TTFB and front-end to understand which side the problem is on, read the profiler and the slow query log, fix the server foundations (recent PHP, OPcache, MySQL with adequate memory), clean up modules and overrides, layer the caching where it helps and, only then, size the hosting on real traffic. Every step is verified by measuring again: if a change doesn&apos;t move the numbers, it wasn&apos;t the bottleneck.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want a PrestaShop that stays fast under load?&quot; text=&quot;We optimise PrestaShop stores across the whole stack: hosting, PHP, MySQL, modules and caching, with before-and-after measurements so the result shows in black and white.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/manual/en/book.opcache.php&quot;&gt;OPcache - official PHP manual&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://dev.mysql.com/doc/refman/8.0/en/innodb-buffer-pool.html&quot;&gt;InnoDB Buffer Pool - official MySQL documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/articles/ttfb&quot;&gt;Time To First Byte - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://devdocs.prestashop-project.org/&quot;&gt;PrestaShop Developer Documentation&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>PHP end of life: what you really risk by staying on an old version</title><link>https://initd.it/en/changelog/php-end-of-life-risks</link><guid isPermaLink="true">https://initd.it/en/changelog/php-end-of-life-risks</guid><description>A site keeps working on an old PHP, until it doesn&apos;t: without security fixes every new flaw stays open forever. What end of support really means and how to upgrade without drama.</description><pubDate>Sun, 09 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&quot;It works, why touch it?&quot; is the sentence that keeps thousands of sites and management tools alive on long-abandoned PHP versions. It&apos;s an understandable sentence: upgrading costs time, the site responds, customers don&apos;t complain. The problem is that the risk of an end-of-life PHP is invisible: it doesn&apos;t slow the page down, it doesn&apos;t show errors, it doesn&apos;t send warnings. Simply, from a certain day on, nobody closes the flaws that get discovered.&lt;/p&gt;
&lt;p&gt;And flaws get discovered anyway. Vulnerability research doesn&apos;t stop when support ends: only the distribution of fixes stops. Everything that surfaces after that date stays open forever, on every server running that version. The &lt;a href=&quot;/en/changelog/php2shell-critical-php-vulnerabilities&quot;&gt;PHP2Shell&lt;/a&gt; case of October 2026 is an example: two critical flaws fixed with official releases only for the supported versions, while the older ones got just minimal source-code fixes to build yourself.&lt;/p&gt;
&lt;h2&gt;What end of support actually means&lt;/h2&gt;
&lt;p&gt;Every PHP version goes through two phases. In the first, &lt;strong&gt;active support&lt;/strong&gt;, it receives fixes of every kind: bugs, performance, security. In the second, &lt;strong&gt;security support&lt;/strong&gt;, it only receives patches for vulnerabilities. When that ends too, the version is &lt;strong&gt;end of life&lt;/strong&gt;: the code keeps running, but it is officially abandoned.&lt;/p&gt;
&lt;p&gt;The dates are public and non-negotiable: the entire PHP 7 family has been end of life since late 2022, PHP 8.0 since late 2023 and PHP 8.1 since late 2025. In the summer of 2026 only PHP 8.2 (which closes at the end of the year), 8.3, 8.4 and 8.5 receive fixes. Anyone still on PHP 7.4 is running software that hasn&apos;t seen a security patch in almost four years. The same mechanism applies one floor down, to the server hosting everything: we cover it when discussing &lt;a href=&quot;/en/changelog/proxmox-8-end-of-life-upgrade&quot;&gt;Proxmox VE 8 at end of life&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;The concrete risks, beyond theory&lt;/h2&gt;
&lt;p&gt;The first risk is obvious: &lt;strong&gt;vulnerabilities with no remedy&lt;/strong&gt;. A site exposed on the internet is probed continuously by automated scanners looking precisely for old installations, because they are the easiest to break into. You don&apos;t need to be an interesting target: being reachable is enough.&lt;/p&gt;
&lt;p&gt;The second is subtler: &lt;strong&gt;the ecosystem moves on&lt;/strong&gt;. Libraries, frameworks and platforms drop old PHP versions long before their users do: new releases of WordPress, &lt;a href=&quot;/en/changelog/prestashop-1-7-8-risks&quot;&gt;PrestaShop&lt;/a&gt;, Laravel and Composer dependencies require recent versions. Standing still on an old PHP means standing still on everything, payment modules and security plugins included.&lt;/p&gt;
&lt;p&gt;The third concerns anyone handling personal data: under the GDPR security measures must be &quot;appropriate to the state of the art&quot;, and a component abandoned by its maker is hard to defend as appropriate, as we discussed in &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR on the infrastructure side&lt;/a&gt;. In case of a breach, the PHP version ends up in the report. For companies subject to NIS2 there is a contractual side too: ACN&apos;s measures only allow software that still gets guaranteed security updates, and the requirements pass on to suppliers, as we explain in &lt;a href=&quot;/en/changelog/nis2-suppliers-what-to-prepare&quot;&gt;NIS2 and suppliers&lt;/a&gt;. When the patches come from the Linux distribution rather than php.net, the case of &lt;a href=&quot;/en/changelog/php-backported-patches-nis2-supported&quot;&gt;backported patches under NIS2&lt;/a&gt; deserves its own discussion.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Not sure which PHP version your sites run on?&quot; text=&quot;We check for you: we inventory versions, extensions and dependencies across your projects and tell you what is at risk and what deserves upgrading first.&quot; button=&quot;Ask for a free audit →&quot;}&lt;/p&gt;
&lt;h2&gt;Upgrading pays off even when it isn&apos;t forced&lt;/h2&gt;
&lt;p&gt;Upgrading PHP is not just removing a risk: it&apos;s one of the few changes that improves performance without touching a line of code. Every recent release runs the same program faster than the previous one, and on a dynamic site the difference is measurable, as our guide on &lt;a href=&quot;/en/changelog/speed-up-prestashop&quot;&gt;speeding up a PrestaShop store&lt;/a&gt; shows. Less CPU time per request also means smaller servers for the same traffic: the upgrade often pays for itself on the hosting bill.&lt;/p&gt;
&lt;h2&gt;How to migrate without drama&lt;/h2&gt;
&lt;p&gt;The migration feared &quot;because everything will break&quot; is handled like any serious intervention: with a method, not with courage.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Inventory&lt;/strong&gt;: which applications run, on which version, with which extensions and dependencies. Without this map every estimate is a bet.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Test on a separate environment&lt;/strong&gt;: replicate the site on a staging environment with the target version and watch logs and &lt;em&gt;deprecation warnings&lt;/em&gt;. Static analysis tools flag incompatible code in advance.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Gradual upgrades&lt;/strong&gt;: better to climb one version at a time than to jump from 7.4 to 8.5 in one leap, fixing incompatibilities in small steps.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Safety net&lt;/strong&gt;: before touching production, &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;a verified backup&lt;/a&gt; and a rollback plan. If something goes wrong, you go back in minutes, not in all-nighters.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;For an e-commerce store or a custom management tool the bulk of the work is almost never PHP itself, but the modules and custom code written years ago: that&apos;s where you want people who do these migrations for a living.&lt;/p&gt;
&lt;h2&gt;In summary&lt;/h2&gt;
&lt;p&gt;An end-of-life PHP version doesn&apos;t stop working: it stops being defended. New flaws stay open forever, the ecosystem of libraries and platforms drifts away, and GDPR compliance becomes hard to sustain. The migration, tackled with an inventory, a staging environment, gradual steps and backups, is an ordinary project rather than a leap into the void; in return you get a site that is safer, faster and free again to update everything else.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want your projects on a supported PHP without stopping anything?&quot; text=&quot;We migrate sites, stores and management tools off end-of-life PHP versions: inventory, staging environment, incompatibility fixes and a backup-guaranteed way back.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/supported-versions.php&quot;&gt;Supported Versions - php.net&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://endoflife.date/php&quot;&gt;PHP - endoflife.date&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.php.net/manual/en/book.opcache.php&quot;&gt;OPcache - official PHP manual&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Pinning the Node.js version with pnpm, without nvm</title><link>https://initd.it/en/changelog/pnpm-node-version</link><guid isPermaLink="true">https://initd.it/en/changelog/pnpm-node-version</guid><description>pnpm can manage the Node.js version too: with devEngines the project declares the runtime it needs and pnpm downloads it, uses it and locks it in the lockfile - no nvm required. Tested examples and the limits to know.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;&quot;It works on my machine.&quot; A good share of the time, behind that sentence there is a different Node.js version: the project was born on 20, a colleague runs 24, CI uses yet another one. The classic tool for living with this is nvm, which installs multiple versions side by side and switches between them. It works, but every person on the team has to install and configure it, and remembering to type &lt;code&gt;nvm use&lt;/code&gt; at the right moment remains a chore. If you already use &lt;strong&gt;pnpm&lt;/strong&gt; as your package manager, there is an often-overlooked alternative: pnpm can manage the Node.js version as well, and it can do it &lt;em&gt;per project&lt;/em&gt;, with no extra tools.&lt;/p&gt;
&lt;h2&gt;The problem, in short&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;Node.js&lt;/strong&gt; is the environment that runs JavaScript outside the browser; every project is effectively tested and guaranteed only on certain versions. &lt;strong&gt;nvm&lt;/strong&gt; (Node Version Manager) tackles the problem by installing several versions side by side: &lt;code&gt;nvm install 20&lt;/code&gt;, &lt;code&gt;nvm use 20&lt;/code&gt; and the current shell switches to 20.&lt;/p&gt;
&lt;p&gt;Its limits are familiar to daily users. nvm is a shell script that must be installed per user and hooked into the shell profile; the version switch applies to the current session, so it has to be repeated (or automated with hooks) for every folder; &lt;a href=&quot;/en/changelog/what-is-a-ci-cd-pipeline&quot;&gt;continuous integration pipelines&lt;/a&gt; and containers typically use a completely different mechanism, with a real risk of drift. That&apos;s not a flaw of nvm: it&apos;s the price of a tool that lives outside the project.&lt;/p&gt;
&lt;h2&gt;The alternative: a runtime declared in the project&lt;/h2&gt;
&lt;p&gt;pnpm flips the approach: the Node.js version becomes a &lt;strong&gt;declaration of the project&lt;/strong&gt;, written in &lt;code&gt;package.json&lt;/code&gt; and versioned with the code. The field is called &lt;code&gt;devEngines&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;{
  &quot;devEngines&quot;: {
    &quot;runtime&quot;: {
      &quot;name&quot;: &quot;node&quot;,
      &quot;version&quot;: &quot;20.19.0&quot;,
      &quot;onFail&quot;: &quot;download&quot;
    }
  }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The key part is &lt;code&gt;onFail: &quot;download&quot;&lt;/code&gt;: if the Node in use doesn&apos;t match the declared one, pnpm &lt;strong&gt;downloads&lt;/strong&gt; the required version on its own (once - it stays in its cache) and uses it for the project, without touching the system Node. The runtime shows up in the &lt;code&gt;pnpm install&lt;/code&gt; output &lt;a href=&quot;/en/changelog/npm-supply-chain-cooldown&quot;&gt;like any other dependency&lt;/a&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ pnpm install
# ...
+ node 20.19.0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;From then on, everything that goes through pnpm uses that version. An example tested while writing this article, on a machine with Node 22 as the system runtime:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ node -v               # the system Node
v22.22.2

$ pnpm run check-node   # a script that runs &quot;node -v&quot;
&amp;gt; node -v
v20.19.0                # the version declared in the project

$ pnpm node -v
v20.19.0
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;No &lt;code&gt;nvm use&lt;/code&gt;, no shell hooks: anyone cloning the repository - a new teammate, CI, a container - gets the same Node version simply by using pnpm.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your team waste time chasing mismatched Node versions between developers and CI?&quot; text=&quot;We review your JavaScript projects&apos; development environments and CI/CD pipeline configuration.&quot; button=&quot;Get a review →&quot;}&lt;/p&gt;
&lt;h2&gt;Ranges work too, and it&apos;s locked in the lockfile&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;version&lt;/code&gt; accepts either an exact version or a &lt;strong&gt;semver range&lt;/strong&gt;. With &lt;code&gt;&quot;version&quot;: &quot;^20.11.0&quot;&lt;/code&gt;, in our test pnpm resolved and downloaded the latest 20.x available:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ pnpm install
# ...
+ node 20.20.2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The most interesting detail is that the resolved version ends up in the &lt;strong&gt;lockfile&lt;/strong&gt; (&lt;code&gt;pnpm-lock.yaml&lt;/code&gt;), like a regular dependency:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;node:
  specifier: runtime:^20.11.0
  version: runtime:20.20.2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This means the whole team and CI use &lt;em&gt;exactly&lt;/em&gt; the same Node version, not just &quot;a compatible one&quot;: the reproducibility is the same the lockfile already guarantees for libraries. The classic &lt;code&gt;engines&lt;/code&gt; field, by comparison, merely warns when the version doesn&apos;t match; &lt;code&gt;devEngines&lt;/code&gt; with &lt;code&gt;onFail: &quot;download&quot;&lt;/code&gt; fixes the problem by itself.&lt;/p&gt;
&lt;h2&gt;The limits to know&lt;/h2&gt;
&lt;p&gt;The mechanism applies to what &lt;strong&gt;goes through pnpm&lt;/strong&gt;: &lt;code&gt;pnpm run&lt;/code&gt;, &lt;code&gt;pnpm exec&lt;/code&gt;, &lt;code&gt;pnpm node&lt;/code&gt;, the scripts in &lt;code&gt;package.json&lt;/code&gt;. If you type &lt;code&gt;node server.js&lt;/code&gt; directly in the terminal, you still get the system Node. In practice this is a smaller limit than it sounds - in JavaScript projects nearly everything goes through the scripts - but it&apos;s worth knowing: &lt;code&gt;devEngines&lt;/code&gt; doesn&apos;t &quot;change the computer&apos;s Node&quot;, it guarantees the &lt;em&gt;project&lt;/em&gt; runs on the right version.&lt;/p&gt;
&lt;p&gt;A note for those coming from earlier versions: up to pnpm 10 there was a &lt;code&gt;use-node-version&lt;/code&gt; setting (or &lt;code&gt;useNodeVersion&lt;/code&gt; in &lt;code&gt;pnpm-workspace.yaml&lt;/code&gt;) doing something similar. &lt;strong&gt;pnpm 11 removed it&lt;/strong&gt;, together with &lt;code&gt;executionEnv.nodeVersion&lt;/code&gt;: the supported path today is &lt;code&gt;devEngines&lt;/code&gt;. If a project still uses those keys, &lt;a href=&quot;/en/changelog/http-deprecation-header&quot;&gt;pnpm 11 silently ignores them&lt;/a&gt; - an easy migration to forget.&lt;/p&gt;
&lt;h2&gt;What about replacing nvm system-wide?&lt;/h2&gt;
&lt;p&gt;pnpm can replace nvm as a global version manager too, via the &lt;code&gt;pnpm env&lt;/code&gt; command:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;pnpm env list 20            # which 20.x versions exist
pnpm env use --global 20    # install and activate the latest 20.x
pnpm env use --global lts   # or the latest LTS
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;An honest caveat: &lt;code&gt;pnpm env&lt;/code&gt; manages the global link to Node, so it requires pnpm to be installed standalone (via the official install script or Corepack), not through &lt;code&gt;npm install -g pnpm&lt;/code&gt; - in that case pnpm would be running &lt;em&gt;inside&lt;/em&gt; the very Node it&apos;s trying to replace. For the per-project usage above, this distinction doesn&apos;t matter.&lt;/p&gt;
&lt;h2&gt;In summary&lt;/h2&gt;
&lt;p&gt;If a project already uses pnpm, pinning the Node.js version doesn&apos;t require nvm: a &lt;code&gt;devEngines&lt;/code&gt; block in &lt;code&gt;package.json&lt;/code&gt; with &lt;code&gt;onFail: &quot;download&quot;&lt;/code&gt; makes pnpm download and use the declared runtime - exact version or range - and locks the actually resolved one in the lockfile, identical for the whole team and CI. The limit is clear (it applies to commands going through pnpm), and anyone coming from pnpm 10 must migrate from &lt;code&gt;use-node-version&lt;/code&gt; to &lt;code&gt;devEngines&lt;/code&gt;. nvm remains useful as a general manager on your own machine; for &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;a project&apos;s reproducibility&lt;/a&gt;, the version declared in the repository is the more solid path.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want reproducible environments for your Node.js projects?&quot; text=&quot;We configure pnpm, CI/CD pipelines and development environments for the Laravel and Vue projects we build and manage.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://pnpm.io/settings&quot;&gt;Settings (pnpm-workspace.yaml) - pnpm documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://pnpm.io/cli/env&quot;&gt;pnpm env - pnpm documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://pnpm.io/blog/releases/11.0&quot;&gt;pnpm 11.0 - release notes&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Compromised npm packages: what happened and how a cooldown period protects you</title><link>https://initd.it/en/changelog/npm-supply-chain-cooldown</link><guid isPermaLink="true">https://initd.it/en/changelog/npm-supply-chain-cooldown</guid><description>The waves of compromised npm packages - from chalk/debug to the Shai-Hulud worm and the 2026 episodes - and a simple, effective defence: pnpm&apos;s minimumReleaseAge, with tested configuration examples.</description><pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;JavaScript developers install third-party libraries dozens of times a day, almost without thinking. One command, a few seconds, and the project has a new dependency - along with all of that dependency&apos;s dependencies. Over the past months this everyday gesture has become the delivery channel for a series of attacks that hit libraries used by millions of projects. The good news: one of the most effective defences is also easy to adopt - waiting a few days before installing freshly published versions. Let&apos;s look at what happened and how to configure this protection with pnpm.&lt;/p&gt;
&lt;h2&gt;What a supply chain attack is&lt;/h2&gt;
&lt;p&gt;Terms first. The &lt;strong&gt;npm registry&lt;/strong&gt; is the public archive JavaScript packages are downloaded from: it holds millions of libraries, published by their maintainers. A &lt;strong&gt;supply chain&lt;/strong&gt; attack doesn&apos;t target your project directly: it targets one of the libraries your project uses. If an attacker manages to publish a modified version of a popular library, everyone who installs it during that window runs the attacker&apos;s code too.&lt;/p&gt;
&lt;p&gt;The weak point is almost always the maintainer&apos;s account. Once the attacker obtains their credentials - usually through phishing, i.e. counterfeit emails and websites imitating the real ones - they publish a new version of the package with malicious code inside. To anyone installing it, that version is indistinguishable from a legitimate update.&lt;/p&gt;
&lt;h2&gt;What happened, briefly&lt;/h2&gt;
&lt;p&gt;The recent episodes give a sense of the scale.&lt;/p&gt;
&lt;p&gt;In &lt;strong&gt;September 2025&lt;/strong&gt; a very active maintainer was fooled by a phishing email imitating npm support (the counterfeit domain was &lt;code&gt;npmjs.help&lt;/code&gt;). His credentials were used to publish malicious versions of 18 packages, including &lt;code&gt;chalk&lt;/code&gt; and &lt;code&gt;debug&lt;/code&gt;: tiny libraries that sit, directly or indirectly, inside a huge share of the ecosystem - together they count billions of downloads per week. The injected code hijacked cryptocurrency transactions in the browser. The compromised versions stayed online for about &lt;strong&gt;two hours&lt;/strong&gt; before being removed.&lt;/p&gt;
&lt;p&gt;A few weeks later came &lt;strong&gt;Shai-Hulud&lt;/strong&gt;, a new kind of attack: a &lt;strong&gt;worm&lt;/strong&gt;, a program that replicates on its own. Starting from the &lt;code&gt;@ctrl/tinycolor&lt;/code&gt; package, once installed it searched the victim&apos;s machine for credentials and &lt;a href=&quot;/en/changelog/oauth-security-bcp&quot;&gt;access tokens&lt;/a&gt; (npm, GitHub, cloud providers), used them to publish infected versions of the victim&apos;s own packages, and so spread from maintainer to maintainer. The affected packages reached into the hundreds, and the stolen secrets were published in automatically created GitHub repositories. In &lt;strong&gt;late November 2025&lt;/strong&gt; a second wave (&quot;Shai-Hulud 2.0&quot;) produced tens of thousands of malicious repositories.&lt;/p&gt;
&lt;p&gt;The phenomenon has not stopped: in the spring of &lt;strong&gt;2026&lt;/strong&gt; researchers documented new campaigns reusing the same techniques - including a third wave of the worm starting in late April - and in &lt;strong&gt;June 2026&lt;/strong&gt; about thirty packages published under the &lt;code&gt;@redhat-cloud-services&lt;/code&gt; namespace were compromised. This is not a complete list, and it will most likely not be the last chapter.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your project still install freshly published npm versions with no filter?&quot; text=&quot;We review the pnpm or npm configuration in your projects and assess whether to turn on a cooldown for new versions.&quot; button=&quot;Ask for a check →&quot;}&lt;/p&gt;
&lt;h2&gt;Why &quot;waiting&quot; is a defence&lt;/h2&gt;
&lt;p&gt;One detail recurs in nearly all these episodes: malicious versions are detected and removed &lt;strong&gt;fast&lt;/strong&gt;. The compromised versions of &lt;code&gt;chalk&lt;/code&gt; and &lt;code&gt;debug&lt;/code&gt; lasted a couple of hours; the Shai-Hulud worm was identified within a dozen hours. The security community monitors the npm registry constantly, and a popular package that starts doing strange things gets reported almost immediately.&lt;/p&gt;
&lt;p&gt;The problem is that during those few hours the damage hits whoever installs &lt;em&gt;right at that moment&lt;/em&gt;. And the version ranges used in &lt;code&gt;package.json&lt;/code&gt; (the classic &lt;code&gt;^1.2.3&lt;/code&gt;, which accepts any newer compatible version) mean a freshly published version is adopted automatically by anyone installing from scratch or updating.&lt;/p&gt;
&lt;p&gt;Hence the idea of a &lt;strong&gt;cooldown&lt;/strong&gt; (or quarantine): never install versions published less than X days ago. It doesn&apos;t protect against everything - an attack that goes unnoticed for longer will get through - but it would have blocked nearly every episode seen so far, at the cost of adopting updates a few days late.&lt;/p&gt;
&lt;h2&gt;Configuring it with pnpm&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;pnpm&lt;/strong&gt; (a package manager alternative to npm, compatible with the same registry, which can also &lt;a href=&quot;/en/changelog/pnpm-node-version&quot;&gt;pin the Node.js version a project uses&lt;/a&gt;) implements this idea with the &lt;code&gt;minimumReleaseAge&lt;/code&gt; setting, expressed in &lt;strong&gt;minutes&lt;/strong&gt;. It goes in the &lt;code&gt;pnpm-workspace.yaml&lt;/code&gt; file at the root of the project:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# pnpm-workspace.yaml
# don&apos;t install versions published less than 3 days ago
minimumReleaseAge: 4320
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;From then on, for every dependency - including &lt;strong&gt;transitive&lt;/strong&gt; ones, the dependencies of your dependencies - pnpm resolves the most recent version that is at least that old. The setting has existed since pnpm 10.16. An example tested while writing this article: as of July 16, 2026 the latest version of &lt;code&gt;@types/node&lt;/code&gt; is 26.1.1, published on July 8. With a 10-day cooldown (&lt;code&gt;minimumReleaseAge: 14400&lt;/code&gt;), pnpm skips 26.1.1 and installs 26.1.0 from July 1, saying so openly:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ pnpm add @types/node
# ...
dependencies:
+ @types/node 26.1.0 (26.1.1 is available)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;No error, no manual step: the too-recent version is simply not considered, and pnpm notes in parentheses that it exists. Once it has aged past the threshold, a normal update will bring it into the project.&lt;/p&gt;
&lt;p&gt;The check doesn&apos;t apply only to new installs: pnpm also verifies the existing &lt;strong&gt;lockfile&lt;/strong&gt;, and if it contains a version younger than the threshold it blocks the install with an explicit error (&lt;code&gt;ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION&lt;/code&gt; - we tested this too). If a specific dependency must be allowed through immediately - an internal company package, or an awaited security fix - you add an exception:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;minimumReleaseAge: 4320
minimumReleaseAgeExclude:
  - &quot;@our-company/*&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;How long should the cooldown be? Since pnpm 11 the setting defaults to &lt;code&gt;1440&lt;/code&gt; minutes (one day), which is already enough for flash episodes like chalk/debug. A value between 3 and 7 days gives more margin, in exchange for slightly less timely updates: a reasonable choice for projects that don&apos;t chase the latest version of everything.&lt;/p&gt;
&lt;h2&gt;The other defences pnpm enables on its own&lt;/h2&gt;
&lt;p&gt;The cooldown works best together with two other protections, already active in recent pnpm versions.&lt;/p&gt;
&lt;p&gt;The first concerns &lt;strong&gt;install scripts&lt;/strong&gt;. Many attacks (Shai-Hulud included) trigger through &lt;em&gt;lifecycle scripts&lt;/em&gt;, commands a package can run automatically at install time. Since pnpm 10 these scripts are &lt;strong&gt;no longer executed&lt;/strong&gt; for dependencies, except those explicitly allowed (the current key is &lt;code&gt;allowBuilds&lt;/code&gt;; earlier versions called it &lt;code&gt;onlyBuiltDependencies&lt;/code&gt;):&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# pnpm-workspace.yaml
# only these packages may run install scripts
allowBuilds:
  - esbuild
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The second is the &lt;strong&gt;lockfile&lt;/strong&gt; (&lt;code&gt;pnpm-lock.yaml&lt;/code&gt;), the file recording the exact versions installed. In CI and production it&apos;s worth installing with &lt;code&gt;pnpm install --frozen-lockfile&lt;/code&gt;: if the lockfile doesn&apos;t match &lt;code&gt;package.json&lt;/code&gt; the install fails instead of resolving new versions, so no update gets in without going through a reviewable change, the same spirit behind &lt;a href=&quot;/en/changelog/cloudflare-oauth-self-managed&quot;&gt;scoping the tokens your pipeline uses down to the minimum they need&lt;/a&gt; instead of leaving them broad.&lt;/p&gt;
&lt;p&gt;npm users aren&apos;t left without options: the &lt;code&gt;--before&lt;/code&gt; flag installs only versions published before a given date (&lt;code&gt;npm install --before=&quot;2026-07-09&quot;&lt;/code&gt;), though it must be passed on every command; as of today there is no stable equivalent of pnpm&apos;s automatic cooldown.&lt;/p&gt;
&lt;h2&gt;In summary&lt;/h2&gt;
&lt;p&gt;npm supply chain attacks are no longer isolated episodes: between late 2025 and 2026 they hit everyday libraries, with a worm able to spread between maintainers on its own. Almost all malicious versions, however, are removed within hours or days of publication. Quarantining versions that are too recent - with pnpm&apos;s &lt;code&gt;minimumReleaseAge&lt;/code&gt;, a value between 1 and 7 days - removes the window where you are most exposed, without changing how you work. Together with blocked install scripts and a frozen lockfile &lt;a href=&quot;/en/changelog/what-is-a-ci-cd-pipeline&quot;&gt;in the pipeline that builds the project&lt;/a&gt;, it is one of the best cost/benefit defences available to JavaScript developers today.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to secure the dependency chain of your JavaScript projects?&quot; text=&quot;We configure minimumReleaseAge, blocked install scripts and a frozen lockfile in CI for the Laravel and Vue projects we build and maintain.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://unit42.paloaltonetworks.com/monitoring-npm-supply-chain-attacks/&quot;&gt;The npm Threat Landscape: Attack Surface and Mitigations - Palo Alto Networks Unit 42&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://unit42.paloaltonetworks.com/npm-supply-chain-attack/&quot;&gt;&quot;Shai-Hulud&quot; Worm Compromises npm Ecosystem in Supply Chain Attack - Unit 42&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://aws.amazon.com/blogs/security/defending-against-supply-chain-attacks-like-chalk-debug-and-the-shai-hulud-worm/&quot;&gt;Defending against supply chain attacks like Chalk/Debug and the Shai-Hulud worm - AWS Security Blog&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://pnpm.io/supply-chain-security&quot;&gt;Mitigating supply chain attacks - pnpm documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://pnpm.io/blog/releases/11.0&quot;&gt;pnpm 11.0 - release notes&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>HTTP QUERY (RFC 10008): a safe method with a body for complex searches</title><link>https://initd.it/en/changelog/http-query-method</link><guid isPermaLink="true">https://initd.it/en/changelog/http-query-method</guid><description>The new HTTP QUERY method, now RFC 10008, lets you run complex searches with a body while staying safe and idempotent: what it is and how it works.</description><pubDate>Mon, 06 Jul 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone who works with web APIs knows the recurring annoyance. When a search gets complex - many filters, lists of values, nested conditions - there&apos;s no genuinely clean way to express it with the HTTP methods we&apos;ve always had. In June 2026 the IETF, the body that maintains Internet&apos;s technical standards, published RFC 10008 and introduced a new HTTP method built for exactly this case. It&apos;s called QUERY.&lt;/p&gt;
&lt;h2&gt;The problem QUERY sets out to solve&lt;/h2&gt;
&lt;p&gt;Every HTTP request has a &quot;method&quot;: a verb that tells the server what you want to do. The best-known ones are GET (read something) and POST (send data, usually to create or change something).&lt;/p&gt;
&lt;p&gt;Anyone designing a search API runs into an uncomfortable fork in the road:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;GET&lt;/strong&gt; is the right method for reading, but its parameters travel in the &lt;em&gt;query string&lt;/em&gt; - the tail of the address after the question mark (&lt;code&gt;?name=value&amp;amp;...&lt;/code&gt;). Addresses, however, have practical length limits: servers, proxies and browsers can truncate or reject overly long URLs. On top of that, the address almost always ends up in logs and in history. Expressing an elaborate filter in a query string quickly becomes unreadable and brittle.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;POST&lt;/strong&gt; lets you attach a &lt;em&gt;body&lt;/em&gt; - the part of the message where the actual data goes, in JSON or other formats. Many APIs use POST for searches purely to get access to that body. The catch is that POST was designed for operations that &lt;em&gt;change&lt;/em&gt; something, and that confuses everything sitting in the middle.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Two terms help here, in plain words. A request is &lt;strong&gt;safe&lt;/strong&gt; when it&apos;s read-only: nothing on the server is expected to change. A request is &lt;strong&gt;idempotent&lt;/strong&gt; when repeating it unchanged doesn&apos;t alter the outcome: sending it once or ten times leaves the same state. GET has both properties; POST does not. That&apos;s why caches and proxies can&apos;t automatically retry a POST after a network error, nor comfortably store its response: they don&apos;t know whether that request &quot;touched&quot; anything.&lt;/p&gt;
&lt;p&gt;The upshot is a choice between two compromises: a clean GET with a query string that bursts at the seams, or a convenient POST that is semantically wrong for a plain search.&lt;/p&gt;
&lt;h2&gt;What the QUERY method is&lt;/h2&gt;
&lt;p&gt;QUERY fills precisely this gap. RFC 10008 describes it as a &lt;strong&gt;safe, idempotent request that carries content&lt;/strong&gt; describing how the target resource should process it, with the resource then responding with the result of that processing.&lt;/p&gt;
&lt;p&gt;In practice: it&apos;s a read-only request like GET, but with a body like POST. The standard is blunt about the two properties. On safety, the client &quot;does not request or expect any change to the state of the target resource&quot;. On idempotency, QUERY requests &quot;are idempotent; they can be retried or repeated when needed, for instance, after a connection failure&quot;.&lt;/p&gt;
&lt;p&gt;Put differently, QUERY gives API designers the thing that neither GET nor POST offers on its own: a complex search, with a structured body, that stays repeatable and cacheable without risk.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your search API still rely on POST just to get around GET&apos;s limits?&quot; text=&quot;We review your endpoints and clients to see whether it&apos;s already worth introducing QUERY or keeping a solid POST fallback.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;GET, POST and QUERY side by side&lt;/h2&gt;
&lt;p&gt;A simple way to pin down the idea:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;GET&lt;/strong&gt; - reads, with no useful body; parameters live in the URL, with its limits.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;POST&lt;/strong&gt; - has a body, but is neither safe nor idempotent: meant to change things.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;QUERY&lt;/strong&gt; - has a body &lt;em&gt;and is&lt;/em&gt; safe and idempotent: meant to interrogate.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The difference isn&apos;t cosmetic. It makes the real intent - &quot;I&apos;m only reading&quot; - explicit to the server, to caches and to proxies, and it unlocks behaviours like automatic retry and cache storage that would be reckless with POST.&lt;/p&gt;
&lt;h2&gt;How it works, concretely&lt;/h2&gt;
&lt;p&gt;A few details from the standard make its use clearer.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;The content type is mandatory.&lt;/strong&gt; A QUERY body can be in any format: JSON, an SQL-like expression, a proprietary filter language. Precisely because of that, the server needs to know what it&apos;s receiving. The RFC requires the server to fail the request if the &lt;code&gt;Content-Type&lt;/code&gt; header is missing or inconsistent with the content, and it forbids &quot;guessing&quot; the format from the data (no &lt;em&gt;content sniffing&lt;/em&gt;). A request with no media type is rejected with a 4xx status, typically 400.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;There&apos;s a way to advertise support.&lt;/strong&gt; The standard introduces a new response header, &lt;code&gt;Accept-Query&lt;/code&gt;, with which a resource can declare that it accepts QUERY and which query formats it understands. An example from the specification: &lt;code&gt;Accept-Query: &quot;application/jsonpath&quot;, application/sql;charset=&quot;UTF-8&quot;&lt;/code&gt;. It gives clients an orderly way to discover that the option is available.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Responses can be cached.&lt;/strong&gt; This is the most tangible practical benefit, because it directly affects &lt;a href=&quot;/en/changelog/ttfb-explained&quot;&gt;the response time users feel&lt;/a&gt;. A QUERY response is cacheable, with one caveat: the &lt;em&gt;cache key&lt;/em&gt; - the identifier used to find the response again - must take the request body and its metadata into account, not just the URL. Caches may normalise insignificant differences in the content to recognise equivalent requests, but only for the purpose of the key, without altering the actual request.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;The response can point to where the result lives.&lt;/strong&gt; The server can include a &lt;code&gt;Content-Location&lt;/code&gt; header pointing to a resource that holds the result of the operation (possibly temporary), or a &lt;code&gt;Location&lt;/code&gt; header naming an &quot;equivalent&quot; resource: an address the client can later hit with a plain GET to repeat the same query without resending the whole body.&lt;/p&gt;
&lt;h2&gt;Security and compatibility: what to watch&lt;/h2&gt;
&lt;p&gt;There are practical points worth weighing before adopting it.&lt;/p&gt;
&lt;p&gt;On privacy there&apos;s a clear benefit: moving the search criteria from the URL into the body keeps sensitive data out of logs more often, because - as the RFC notes - the address is logged and processed by intermediaries far more than the content is. The standard also recommends that, if the server creates a temporary resource for the result, the assigned address shouldn&apos;t contain sensitive parts of the original query.&lt;/p&gt;
&lt;p&gt;Adoption friction remains, though. In browsers, a cross-origin QUERY requires a CORS &lt;em&gt;preflight&lt;/em&gt; - a preliminary check the browser performs to verify permissions - because QUERY isn&apos;t among the methods treated as &quot;safe by default&quot;. It&apos;s also worth remembering that the exception whereby a redirect turns a POST into a GET (301 or 302 responses) does not apply to QUERY. And, plainly, every link in the chain - proxies, web servers, frameworks, client libraries - has to learn to recognise the new method: until it does, a QUERY can be blocked or mishandled.&lt;/p&gt;
&lt;h2&gt;Where standardisation stands&lt;/h2&gt;
&lt;p&gt;A clarification is needed here, because the old wording is still floating around. For years this proposal existed as an &lt;em&gt;Internet-Draft&lt;/em&gt; named &lt;code&gt;draft-ietf-httpbis-safe-method-w-body&lt;/code&gt;, developed by the IETF&apos;s httpbis working group, the same one behind &lt;a href=&quot;/en/changelog/http-deprecation-header&quot;&gt;the header that flags deprecated APIs&lt;/a&gt; and &lt;a href=&quot;/en/changelog/http-concealed-auth&quot;&gt;the concealed authentication scheme&lt;/a&gt;. In November 2025 the text was approved, and in June 2026 it was published as &lt;strong&gt;RFC 10008&lt;/strong&gt;. So it&apos;s no longer a mere draft: it&apos;s a published document.&lt;/p&gt;
&lt;p&gt;Mind the maturity level, though. RFC 10008 is a &lt;strong&gt;Proposed Standard&lt;/strong&gt;, the first stable rung on the IETF standards track: a mature text, publicly reviewed and citable, but not yet the final &quot;Internet Standard&quot; level. In practical terms the specification is solid, while real support across servers, proxies and frameworks is still spreading.&lt;/p&gt;
&lt;p&gt;The authors are Julian Reschke (greenbytes), James M. Snell (Cloudflare) and Mike Bishop (Akamai). The presence of Cloudflare and Akamai, two large network and CDN operators, is a useful signal: they are exactly the players who need to support the method along the path for it to become usable at scale, the same push behind Cloudflare&apos;s experiments on other fronts of the protocol, such as &lt;a href=&quot;/en/changelog/pay-per-crawl&quot;&gt;a new use of the HTTP 402 status for AI crawler traffic&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;Why it can help API developers&lt;/h2&gt;
&lt;p&gt;QUERY&apos;s value isn&apos;t yet another acronym; it&apos;s giving a correct name to something people were already doing by bending their tools. Those who have used POST for searches did so for a legitimate technical reason - they needed a body - but paid for it in clarity and lost caching and automatic retry.&lt;/p&gt;
&lt;p&gt;Looking ahead, for an API with elaborate searches it&apos;s worth considering QUERY as the more honest alternative: it keeps read semantics, sidesteps URL limits, keeps criteria out of the logs and reopens the door to caching. In the meantime, since adoption across the chain isn&apos;t universal yet, a prudent approach is to keep a POST fallback and to check how proxies and clients behave before relying on QUERY alone in production. It&apos;s one of those changes that won&apos;t upend everything tomorrow, but that over a few years can reasonably be expected as a standard option in search APIs.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Designing or reviewing an API with complex searches?&quot; text=&quot;We build custom APIs in Laravel and PHP: we help you decide if and how to introduce QUERY, with an eye on caching, proxies and client compatibility.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc10008.html&quot;&gt;RFC 10008: The HTTP QUERY Method (RFC Editor)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://datatracker.ietf.org/doc/rfc10008/&quot;&gt;RFC 10008 - The HTTP QUERY Method (IETF Datatracker)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://datatracker.ietf.org/doc/draft-ietf-httpbis-safe-method-w-body/&quot;&gt;draft-ietf-httpbis-safe-method-w-body (IETF httpbis working group)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>TTFB: What Time To First Byte Is and Why It Matters for Site Performance</title><link>https://initd.it/en/changelog/ttfb-explained</link><guid isPermaLink="true">https://initd.it/en/changelog/ttfb-explained</guid><description>What TTFB (Time To First Byte) is, why it affects user experience and SEO, what it depends on, and the general levers that help reduce it.</description><pubDate>Sun, 28 Jun 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;When you open a web page, there&apos;s a moment of waiting before anything shows up: the loading indicator spins, the screen stays blank, and only then do text and images start to appear. A large part of that initial wait has a precise name: &lt;strong&gt;TTFB&lt;/strong&gt;, or &lt;em&gt;Time To First Byte&lt;/em&gt;. Understanding what it is helps you reason about a site&apos;s performance without relying on vague impressions.&lt;/p&gt;
&lt;h2&gt;What TTFB is, in plain terms&lt;/h2&gt;
&lt;p&gt;TTFB measures the time between the moment the browser starts requesting a page and the moment it receives the &lt;strong&gt;first byte&lt;/strong&gt; of the response from the server. In practice, it&apos;s how long the server takes to &lt;em&gt;start&lt;/em&gt; replying, not to finish.&lt;/p&gt;
&lt;p&gt;A useful comparison: it&apos;s like ordering at a restaurant. TTFB isn&apos;t the time to finish your meal, nor the time to have the full dish in front of you. It&apos;s the time between placing the order and the waiter coming back with the first course. If that first signal arrives late, everything else slips accordingly.&lt;/p&gt;
&lt;p&gt;It&apos;s worth clarifying one point right away: TTFB isn&apos;t a single thing, but the sum of several steps. According to web.dev&apos;s documentation, it includes the time for any &lt;strong&gt;redirects&lt;/strong&gt; (bouncing from one address to another), the startup of a &lt;em&gt;service worker&lt;/em&gt; if present, &lt;strong&gt;DNS resolution&lt;/strong&gt; (translating the site&apos;s name into the server&apos;s numeric address), &lt;strong&gt;connection and TLS negotiation&lt;/strong&gt; (the encrypted &quot;handshake&quot; that protects the data) and finally the processing of the request up to the first byte returned.&lt;/p&gt;
&lt;h2&gt;Why it matters to the people using the site&lt;/h2&gt;
&lt;p&gt;The first byte isn&apos;t visible content yet: it&apos;s just the signal that the response has begun. But until it arrives, the browser can&apos;t do anything. It can&apos;t read the HTML, download images or stylesheets, or draw anything on screen. A high TTFB pushes &lt;em&gt;everything&lt;/em&gt; that follows further out.&lt;/p&gt;
&lt;p&gt;For the user, this turns into a concrete feeling: the site seems &quot;slow to start.&quot; Even if the rest is well optimized, a server that takes too long to respond leaves the screen empty for longer, and the page feels like it isn&apos;t working. On this point the guidelines offer a practical reference: a TTFB is considered &lt;strong&gt;good at 0.8 seconds or less&lt;/strong&gt; and &lt;strong&gt;poor above 1.8 seconds&lt;/strong&gt;. It&apos;s not an absolute cutoff, but a useful order of magnitude to judge whether there&apos;s room to improve.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do you know how long your site takes just to start responding?&quot; text=&quot;We measure your site&apos;s TTFB and tell you whether the bottleneck is the server, the application or the database.&quot; button=&quot;Measure your TTFB →&quot;}&lt;/p&gt;
&lt;h2&gt;TTFB, SEO and Core Web Vitals&lt;/h2&gt;
&lt;p&gt;This needs some context. Google uses a set of metrics called &lt;strong&gt;Core Web Vitals&lt;/strong&gt; to measure the quality of a page&apos;s loading experience, and these metrics are a factor that influences ranking in search results. There are three: &lt;strong&gt;LCP&lt;/strong&gt; (&lt;em&gt;Largest Contentful Paint&lt;/em&gt;, how long before the main content appears, good under 2.5 seconds), &lt;strong&gt;INP&lt;/strong&gt; (&lt;em&gt;Interaction to Next Paint&lt;/em&gt;, how responsive the page is to clicks, good under 200 milliseconds) and &lt;strong&gt;CLS&lt;/strong&gt; (&lt;em&gt;Cumulative Layout Shift&lt;/em&gt;, how much elements &quot;jump&quot; as the page loads, good under 0.1). Note that in 2024 &lt;a href=&quot;/en/changelog/inp-core-web-vital&quot;&gt;INP replaced the older FID metric&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;TTFB, on its own, &lt;strong&gt;isn&apos;t one of the Core Web Vitals&lt;/strong&gt;. But it precedes all of them. It&apos;s the first building block that LCP in particular is built on: web.dev&apos;s documentation describes it as the first part of LCP and estimates it can account for roughly 40% of it. The principle is simple: nothing can happen on the page until the server delivers that first byte, so anything that lowers TTFB tends to improve the other loading metrics too. Reducing TTFB doesn&apos;t guarantee a good score by itself, but a high TTFB makes one much harder to reach.&lt;/p&gt;
&lt;h2&gt;What TTFB depends on&lt;/h2&gt;
&lt;p&gt;TTFB doesn&apos;t come from a single factor, which is why it&apos;s sometimes hard to diagnose. In general several layers come into play.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;The network and geographic distance.&lt;/strong&gt; Every request physically travels between the user and the server. The farther apart they are, the more time is spent just moving the data, on top of the initial DNS lookup and TLS handshake.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The server and hosting.&lt;/strong&gt; An overloaded, undersized, or outdated server responds more slowly. &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;Hosting quality&lt;/a&gt; is often the first thing to evaluate.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The application.&lt;/strong&gt; The code that generates the page can do heavy work on every request: computations, calls to external services, unoptimized processing. All of it piles up before the first byte.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The database.&lt;/strong&gt; If generating the page requires slow or too many queries, the server waits on the database before it can respond.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Caching (or the lack of it).&lt;/strong&gt; If every request is recomputed from scratch, you pay the full cost every time. Caching exists precisely to avoid that.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A high TTFB, then, is a symptom: the value has to be broken down to understand &lt;em&gt;where&lt;/em&gt; the time is lost.&lt;/p&gt;
&lt;h2&gt;The general levers to improve it&lt;/h2&gt;
&lt;p&gt;There&apos;s no single fix that works for everyone, and it&apos;s always worth measuring before and after. That said, the common approaches are just a few, and they act on the layers described above.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Caching.&lt;/strong&gt; This is often the lever with the best effort-to-result ratio. The idea is to serve a ready-made result instead of recomputing it. It can happen at several levels: a &lt;em&gt;page cache&lt;/em&gt; that keeps the already-generated HTML, a cache of data or queries and &lt;code&gt;Cache-Control&lt;/code&gt; headers, which tell browsers and intermediaries when to reuse a response. With effective caching, only the first request pays the full cost back to the origin server.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;CDN (Content Delivery Network).&lt;/strong&gt; A CDN is a network of geographically distributed servers that bring content closer to the user. It serves the response from a nearby node instead of the distant origin server, cutting the data&apos;s travel time; CDNs also generally offer fast DNS, modern protocols like HTTP/2 and HTTP/3, and &lt;a href=&quot;/en/changelog/tls-certificates-47-days&quot;&gt;optimized TLS handling&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Backend optimization.&lt;/strong&gt; This covers everything that makes generating the response faster: more efficient database queries, less work done on each request, updated infrastructure. It&apos;s the least &quot;magical&quot; and most hands-on part, but often the most decisive when the bottleneck is the application, as frequently happens with &lt;a href=&quot;/en/changelog/speed-up-prestashop&quot;&gt;an online store grown over the years&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Reducing redirects.&lt;/strong&gt; Every bounce from one address to another adds a full network round trip before the server even starts replying. Removing needless redirects, where they&apos;re under your control, helps.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;TTFB is the time before the first byte of the response: a small but foundational value, because the rest of the load starts from there. It isn&apos;t an official Core Web Vitals metric, but it shapes them, which is why it affects both perceived experience and, indirectly, SEO. It depends on network, server, application, database and caching, and it&apos;s addressed mainly through caching, CDNs and backend optimization. The practical rule stays the same: measure, find where the time is lost, and act on the right layer instead of changing everything at random.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want a site that responds instantly, not just loads fast?&quot; text=&quot;We work on hosting, caching and the backend to cut TTFB, from server tuning to fixing the slowest queries.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/articles/ttfb&quot;&gt;Time to First Byte (TTFB) - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/articles/optimize-ttfb&quot;&gt;Optimize Time to First Byte - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/articles/vitals&quot;&gt;Web Vitals - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/articles/optimize-lcp&quot;&gt;Optimize Largest Contentful Paint - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Cloudflare opens self-managed OAuth to every developer</title><link>https://initd.it/en/changelog/cloudflare-oauth-self-managed</link><guid isPermaLink="true">https://initd.it/en/changelog/cloudflare-oauth-self-managed</guid><description>As of June 2026, anyone using Cloudflare can create their own OAuth clients with fine-grained permissions instead of broad API tokens. What it is, the problem it solves, and why it matters for people building integrations.</description><pubDate>Thu, 18 Jun 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone who builds a program that has to &quot;talk&quot; to an online service - say an app that manages sites, DNS or firewalls on a customer&apos;s behalf - sooner or later hits a practical question: how do I let my software access someone else&apos;s account, securely, without asking for their password? On June 3, 2026, Cloudflare - one of the world&apos;s largest network and CDN operators - made a tool built for exactly this available to all its customers: self-managed OAuth, meaning the ability to create your own OAuth applications yourself. Until shortly before, it was a feature reserved for a small group of hand-approved partners; now anyone with an account can use it.&lt;/p&gt;
&lt;h2&gt;The starting point: API tokens&lt;/h2&gt;
&lt;p&gt;To understand the news, it helps to look at how you access the Cloudflare API today. An &lt;em&gt;API&lt;/em&gt; is the interface a program uses to command a service without going through the website: creating a DNS record, adding a rule, reading some statistics. To authorize these actions you normally use an &lt;em&gt;API token&lt;/em&gt;: a long secret string that works like a key. Whoever holds it can perform whatever that token allows.&lt;/p&gt;
&lt;p&gt;Tokens do the job, but they carry some awkward limits when you&apos;re building integrations for other people. They&apos;re often long-lived and broadly scoped, because it&apos;s convenient to mint one that &quot;does everything&quot;. They have to be handed to the program that will use them, which means sharing a secret: if it ends up in the wrong place, maybe through a compromised software dependency as happened recently with the &lt;a href=&quot;/en/changelog/npm-supply-chain-cooldown&quot;&gt;quarantined npm packages&lt;/a&gt;, whoever holds it can act on the account until the token is deleted. And if a customer wants to revoke access for a single application, working out which token belongs to whom isn&apos;t always straightforward. In short: handy for personal use, a poor fit for delegating limited access to third-party software.&lt;/p&gt;
&lt;h2&gt;What OAuth is, and what changes&lt;/h2&gt;
&lt;p&gt;&lt;em&gt;OAuth&lt;/em&gt; is an authorization standard used across the web. It&apos;s the same mechanism behind the &quot;Sign in with Google&quot; or &quot;Connect your account&quot; buttons: instead of handing over a password or a key, the user is sent to the service&apos;s own site, confirms which permissions to grant the application, and comes back with a limited authorization. The application never sees the user&apos;s credentials; it only receives permission to do the little it was granted.&lt;/p&gt;
&lt;p&gt;Compared with a token handed over by hand, the OAuth model brings three concrete benefits. The first is &lt;em&gt;explicit consent&lt;/em&gt;: the user decides, in front of a clear screen, what to authorize. The second is &lt;em&gt;least privilege&lt;/em&gt;: the application asks only for the permissions it needs, not the keys to everything. The third is &lt;em&gt;clean revocation&lt;/em&gt;: the user can remove access for that single application from their dashboard, without touching anything else.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Are your API tokens still carrying overly broad permissions?&quot; text=&quot;We review how your integrations access external services and where a more fine-grained authorization model is needed.&quot; button=&quot;Get a review →&quot;}&lt;/p&gt;
&lt;h2&gt;What Cloudflare announced&lt;/h2&gt;
&lt;p&gt;The change is that any Cloudflare customer can now create and manage their own OAuth applications on their own, without being a selected partner. You do it from the dashboard, under &lt;strong&gt;Manage account &amp;gt; OAuth clients&lt;/strong&gt;, or via the API if you prefer to automate. From there you define the application, choose the permissions, and get the credentials you need to start the authorization flow.&lt;/p&gt;
&lt;p&gt;It&apos;s a feature available to everyone (general availability), not a beta. Cloudflare describes it as a more secure, more user-friendly and more manageable alternative to API tokens, especially for scenarios where an application acts on a user&apos;s behalf.&lt;/p&gt;
&lt;h2&gt;Fine-grained permissions&lt;/h2&gt;
&lt;p&gt;At the heart of it are &lt;em&gt;scopes&lt;/em&gt;, the permissions an application can request. On Cloudflare, scope names correspond to the same permissions you&apos;d find when creating an API token, so you can pick exactly what to grant access to - read-only DNS for a zone, say, or management of one specific feature - instead of handing over everything at once. You can browse the available scopes from the dashboard while creating the client, or fetch them via the API.&lt;/p&gt;
&lt;p&gt;The practical effect is that a well-built integration asks only for what it needs. If that application is ever compromised, the damage stays confined to the permissions it was granted, not the whole account.&lt;/p&gt;
&lt;h2&gt;Private and public clients, and the consent screen&lt;/h2&gt;
&lt;p&gt;Cloudflare distinguishes two kinds of application. A &lt;em&gt;private client&lt;/em&gt; can be authorized only by members of the account that created it: it&apos;s meant for an organization&apos;s internal tools. A &lt;em&gt;public client&lt;/em&gt; can instead be authorized by any Cloudflare user: that&apos;s the case for a SaaS product offering a &quot;connect your Cloudflare account&quot; button to its customers.&lt;/p&gt;
&lt;p&gt;Public clients come with an extra step to protect users: domain verification. Whoever publishes the application has to prove they control their domain by adding a DNS TXT record with a code Cloudflare provides. Once verified, the application earns a badge on the consent screen, so anyone about to authorize it knows who they&apos;re dealing with. That same screen was reworked to make it clear which application is requesting access and what permissions it receives.&lt;/p&gt;
&lt;h2&gt;Client secrets and PKCE&lt;/h2&gt;
&lt;p&gt;A technical detail worth knowing for anyone building these integrations: Cloudflare supports the OAuth 2.0 flow called &lt;em&gt;authorization code&lt;/em&gt;, in line with the &lt;a href=&quot;/en/changelog/oauth-security-bcp&quot;&gt;latest OAuth security best practices&lt;/a&gt;, and rules out other types that are a poorer fit for secure delegated access. In this flow, an application running on its own server can hold a &lt;em&gt;client secret&lt;/em&gt;, an application password kept out of sight. Applications that instead run entirely on the user&apos;s device - a mobile app, a desktop program, a web page - can&apos;t hide a secret and must use a mechanism called &lt;em&gt;PKCE&lt;/em&gt;, which protects the exchange without needing to guard a key. It&apos;s an important distinction: the explicit advice is never to embed the client secret in code that ends up on the user&apos;s device.&lt;/p&gt;
&lt;h2&gt;What it&apos;s for&lt;/h2&gt;
&lt;p&gt;Three scenarios open up in particular. The first is SaaS products that manage Cloudflare infrastructure on customers&apos; behalf: they can now offer a real &quot;connect your account&quot; flow, with targeted permissions, instead of asking the user to generate and paste a token. The second is internal developer platforms: a company can build tools that act on its own Cloudflare resources with per-user authorization. The third, more recent, involves AI &lt;em&gt;&lt;a href=&quot;/en/changelog/agent-skills&quot;&gt;agents&lt;/a&gt;&lt;/em&gt; and &lt;a href=&quot;/en/changelog/what-is-mcp&quot;&gt;MCP servers&lt;/a&gt; - programs that act on a person&apos;s behalf: they too finally have a delegated-access model built for the purpose, rather than having to be handed a broadly scoped token.&lt;/p&gt;
&lt;h2&gt;Why it matters&lt;/h2&gt;
&lt;p&gt;The value isn&apos;t in a single flashy feature, but in removing friction from a recurring problem. People building integrations can ask only for the permissions they need, users can see clearly what they&apos;re authorizing, and they can revoke access for a specific application with one click. It&apos;s the model most of the web is already used to, now extended to the Cloudflare API and opened to anyone, not just partners.&lt;/p&gt;
&lt;p&gt;It should be said plainly that this doesn&apos;t retire API tokens: for personal use or quick scripts they stay simpler and more direct. Self-managed OAuth shines when a third party is involved and you need to delegate limited access in a controlled way. Under the hood, to make the service available to everyone, Cloudflare upgraded the OAuth engine it relies on (the open source project Ory Hydra) through a zero-downtime migration: work invisible to users, but it explains why the feature only arrives now. For anyone building integrations with Cloudflare, it&apos;s a missing piece that&apos;s finally in place and worth trying on a real project.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Need to build an integration that accesses a customer&apos;s data securely?&quot; text=&quot;We build Laravel integrations with OAuth, scope management and clean access revocation, instead of generic tokens passed around by hand.&quot; button=&quot;Let&apos;s design the integration →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.cloudflare.com/oauth-for-all/&quot;&gt;Unlocking the Cloudflare app ecosystem with OAuth for all (Cloudflare Blog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developers.cloudflare.com/changelog/post/2026-06-03-public-oauth-clients/&quot;&gt;Introducing self-managed OAuth clients (Cloudflare Changelog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developers.cloudflare.com/fundamentals/oauth/&quot;&gt;OAuth Applications on Cloudflare (Cloudflare Fundamentals docs)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developers.cloudflare.com/fundamentals/oauth/create-an-oauth-client/&quot;&gt;Create your OAuth client (Cloudflare Fundamentals docs)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>AWS Graviton5 and the new EC2 instances: why ARM chips in the cloud matter</title><link>https://initd.it/en/changelog/aws-graviton5</link><guid isPermaLink="true">https://initd.it/en/changelog/aws-graviton5</guid><description>AWS has made its EC2 M9g and M9gd instances generally available, powered by the Graviton5 ARM processor. What changes and what to check before moving your Linux workloads onto them.</description><pubDate>Wed, 10 Jun 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;On 10 June 2026 AWS made two new kinds of virtual server generally available in its cloud: the EC2 instances called M9g and M9gd. The news under the hood is the processor that powers them, Graviton5, first shown in preview in late 2025 and now reaching general availability. It&apos;s a good moment to explain, without needless jargon, something that by now concerns anyone who rents servers in the cloud: why ARM processors are gaining ground, and what&apos;s worth checking before moving your own programs onto them.&lt;/p&gt;
&lt;h2&gt;What &quot;ARM&quot; and &quot;instance&quot; mean, briefly&lt;/h2&gt;
&lt;p&gt;An EC2 &lt;strong&gt;instance&lt;/strong&gt; is simply a virtual server you rent by the hour: you give it some computing power and memory, install Linux on it, and run your services. The &quot;engine&quot; of that server is the processor - the chip that does the calculations.&lt;/p&gt;
&lt;p&gt;For years, server processors nearly all followed the same underlying design, the one used by Intel and AMD chips, known as &lt;strong&gt;x86&lt;/strong&gt;. &lt;strong&gt;ARM&lt;/strong&gt; is a different way of building processors: it&apos;s the same architecture family found in smartphones and modern laptops, born with a strong focus on power consumption. The technical difference doesn&apos;t concern the end user; the practical consequence does: for the same amount of work, an ARM chip tends to draw less power and cost less to run.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Graviton&lt;/strong&gt; is the line of ARM processors AWS designs itself, rather than buying from others. It isn&apos;t brand new: it has existed for a few years and has now reached its fifth generation. Graviton5 is that latest step.&lt;/p&gt;
&lt;h2&gt;Why ARM chips in the cloud matter&lt;/h2&gt;
&lt;p&gt;The point isn&apos;t rooting for one technology over another. The point is the bill, and the power draw.&lt;/p&gt;
&lt;p&gt;In the cloud you pay for compute time. If the same service runs on a chip that gets more done for the same electricity, the provider can offer that compute at a lower price. Historically, AWS&apos;s ARM instances have been listed below their x86 equivalents, and it&apos;s this combination - performance per euro spent and modest consumption - that led many companies to start looking at them.&lt;/p&gt;
&lt;p&gt;Then there&apos;s the data-centre side, both environmental and financial. A processor that does the same job with less energy means less heat to remove and less electricity on the bill: two heavy line items for anyone running thousands of servers.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Is your current AWS bill heavier than it needs to be?&quot; text=&quot;We check whether your Linux workloads are ARM-compatible and how much you&apos;d save by moving to Graviton.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;What changes with Graviton5&lt;/h2&gt;
&lt;p&gt;AWS describes Graviton5 as the most powerful and most energy-efficient processor it has ever built. The stated figures - always to be read with the &quot;up to&quot; in front, since they&apos;re peak values and not guaranteed averages - are these:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;up to 25% more compute performance&lt;/strong&gt; than the previous generation, Graviton4;&lt;/li&gt;
&lt;li&gt;looking at specific workloads, &lt;strong&gt;up to 35% faster&lt;/strong&gt; for web applications, &lt;strong&gt;up to 35%&lt;/strong&gt; for machine-learning inference (that is, using a model that has already been trained) and &lt;strong&gt;up to 30%&lt;/strong&gt; for databases;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;192 cores&lt;/strong&gt; per processor (cores are the independent computing units: more cores means more things running in parallel);&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;five times more L3 cache&lt;/strong&gt; than the previous generation. Cache is a small, very fast memory next to the processor: the larger it is, the less the chip has to stop and wait for data;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;up to 33% lower latency between cores&lt;/strong&gt;, meaning the cores exchange information more quickly;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;DDR5-8800&lt;/strong&gt; memory, among the fastest available in the cloud today.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;These are vendor figures. They remain a useful indication of the direction, but the real gain always depends on the specific workload.&lt;/p&gt;
&lt;h2&gt;The two instances: M9g and M9gd&lt;/h2&gt;
&lt;p&gt;The new instances come in two variants that share the same processor.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;M9g&lt;/strong&gt; is the general-purpose version, suited to most services: websites, web applications, backends, normal-sized databases. Sizes range from 1 vCPU with 4 GiB of memory up to 192 vCPUs with 768 GiB. A &lt;strong&gt;vCPU&lt;/strong&gt; is the slice of processor assigned to the instance; here the ratio is one vCPU for every four GiB of memory.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;M9gd&lt;/strong&gt; adds &lt;a href=&quot;/en/changelog/lvm-storage&quot;&gt;&lt;strong&gt;local NVMe storage&lt;/strong&gt;&lt;/a&gt; - very fast solid-state memory physically attached to the server - up to 11.4 TB. It&apos;s for those who need to read and write data locally at high speed, for example &lt;a href=&quot;/en/changelog/aws-aurora-dsql&quot;&gt;certain databases&lt;/a&gt; or caching systems, without going through a network disk. For this variant AWS also cites an increase in read/write operations per second compared with the past.&lt;/p&gt;
&lt;p&gt;The instances can be bought in AWS&apos;s usual ways (on demand, with savings plans, as Spot for interruptible workloads, and in dedicated forms) and, at launch, are available in a handful of regions: the United States (Northern Virginia, Ohio, Oregon) and Europe (Frankfurt). Coverage is therefore still partial, as is normal for something just released.&lt;/p&gt;
&lt;p&gt;On security, AWS builds them on the sixth generation of its Nitro system and introduces a component called the Nitro Isolation Engine, which strengthens the isolation between virtual machines sharing the same physical hardware.&lt;/p&gt;
&lt;h2&gt;What to weigh before moving your Linux workloads&lt;/h2&gt;
&lt;p&gt;Going from x86 to ARM isn&apos;t just a change of size. It&apos;s a change of processor architecture, and that has concrete consequences. Here are the points to check, in order of importance.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;The software must exist in an ARM build.&lt;/strong&gt; A program compiled for x86 won&apos;t run on ARM as it is. The good news is that the most common Linux distributions (Debian, Ubuntu, Amazon Linux, RHEL and its relatives) have long offered 64-bit ARM builds, labelled &lt;code&gt;arm64&lt;/code&gt; or &lt;code&gt;aarch64&lt;/code&gt;. Most interpreted languages - PHP, Python, Node.js, Java - work without rewriting anything.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Watch the compiled dependencies.&lt;/strong&gt; The trouble hides in &quot;native&quot; components: language extensions, system libraries, proprietary software shipped as a ready-made binary. If a piece exists only for x86, it has to be replaced, recompiled or set aside. It&apos;s worth taking stock of what your stack relies on ahead of time, a faster job when the infrastructure is already &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;described as code&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Check your container images.&lt;/strong&gt; Anyone using Docker should confirm the images are &quot;multi-architecture&quot;, that is, also available for &lt;code&gt;linux/arm64&lt;/code&gt;. Many official images already are; ones built in-house need rebuilding for ARM.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Test with your own data, not with the list figures.&lt;/strong&gt; The stated percentages are peak values. The only test that counts is measuring your real workload on a small ARM instance and comparing it with the x86 one you use today, looking at both performance and the &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;actual cost in your region&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Confirm the price case by case.&lt;/strong&gt; ARM&apos;s cost advantage is historically real, but it isn&apos;t a fixed law: it depends on the region, the size and the purchase form. Confirm it on the quote, don&apos;t take it for granted.&lt;/p&gt;
&lt;p&gt;In practice, for many modern Linux services the move to ARM is less painful today than people fear, and the saving can be real. For older stacks, or ones full of proprietary components, it&apos;s better to take it slowly: first an inventory of the software, then a side-by-side trial, and only then the decision. Graviton5 makes the ARM option more appealing, but the right choice is still the one measured against your own case.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Thinking about moving your servers to ARM?&quot; text=&quot;We handle Linux systems management on AWS and Google Cloud: auditing your stack, benchmarking on Graviton, and running the migration without downtime.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://aws.amazon.com/blogs/aws/now-available-amazon-ec2-m9g-and-m9gd-instances-powered-by-new-aws-graviton5-processors/&quot;&gt;Now available: Amazon EC2 M9g and M9gd instances powered by new AWS Graviton5 processors (AWS News Blog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.aboutamazon.com/news/aws/aws-graviton-5-cpu-amazon-ec2&quot;&gt;AWS Graviton5 is now generally available (About Amazon)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>S3 disables SSE-C by default on new buckets: what changes and what to check</title><link>https://initd.it/en/changelog/aws-s3-sse-c-default</link><guid isPermaLink="true">https://initd.it/en/changelog/aws-s3-sse-c-default</guid><description>Amazon S3 now disables customer-provided key encryption (SSE-C) by default on new buckets: what it is, why the default changed, and what to verify first.</description><pubDate>Thu, 16 Apr 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;A default setting, when it changes, can go unnoticed until something stops working. That&apos;s the case with an update Amazon Web Services (AWS) began rolling out in April 2026 for its S3 storage service: encryption with a customer-provided key, known as SSE-C, is no longer active by default on new buckets. A bucket is the basic container in which S3 keeps files, which in the service&apos;s jargon are called objects, the same concept reused by the more recent &lt;a href=&quot;/en/changelog/aws-s3-vectors&quot;&gt;vector buckets&lt;/a&gt; for semantic search. For most people using S3, nothing changes. But anyone with automation or applications that rely on SSE-C has good reason to check their configurations before the change reaches everywhere.&lt;/p&gt;
&lt;h2&gt;What SSE-C is, and where it fits&lt;/h2&gt;
&lt;p&gt;S3 offers server-side encryption: data is encrypted automatically when it&apos;s written to disk and decrypted on read, without the application having to deal with it. The difference between the variants comes down to a single question: who owns and manages the key.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;SSE-S3&lt;/strong&gt; - the key is generated and managed by AWS. It&apos;s the simplest option and the default.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;SSE-KMS&lt;/strong&gt; - the key lives in AWS Key Management Service (KMS), the dedicated key-management service. In exchange you get fine-grained access controls through IAM policies (AWS&apos;s permission system) and a record of every use of the key in CloudTrail, the account&apos;s activity log, a level of traceability that lines up well with the &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;accountability required under GDPR&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;SSE-C&lt;/strong&gt; - the key is supplied by the customer, and sent to S3 with every write and read request. S3 uses it to encrypt or decrypt on the fly, but never stores it anywhere. Control of the key stays entirely with whoever produces it.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;That last point is what makes SSE-C distinctive: because S3 doesn&apos;t store the key, without it the data can&apos;t be read, not even on AWS&apos;s side. It&apos;s a strong guarantee, but also a heavy operational constraint.&lt;/p&gt;
&lt;h2&gt;What actually changes&lt;/h2&gt;
&lt;p&gt;The update concerns general purpose buckets, the standard kind used in the vast majority of cases.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;New buckets&lt;/strong&gt;: SSE-C is disabled by default. Every bucket created after the rollout starts with SSE-C blocked.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Existing buckets&lt;/strong&gt;: it depends on the account. If the account contains no SSE-C-encrypted objects, S3 disabled SSE-C on the existing buckets too. If even a single bucket in the account holds SSE-C objects, S3 left every configuration in that account untouched, so as not to break what&apos;s in use.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Timing and Regions&lt;/strong&gt;: the rollout began in April 2026 and reached 37 AWS Regions, including the AWS China and AWS GovCloud (US) Regions. The Middle East (Bahrain) and Middle East (UAE) Regions are an exception, at least for now, where the new default doesn&apos;t apply. The change didn&apos;t come out of nowhere: AWS published an advance notice back in November 2025.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;It&apos;s worth stressing that this is a real, already-live change, not a beta or a proposal: the default really did change.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do you know which of your S3 buckets still depend on SSE-C?&quot; text=&quot;We check your buckets&apos; encryption configuration and confirm whether the new AWS default could break writes in production.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;Why AWS is doing it&lt;/h2&gt;
&lt;p&gt;The stated rationale is that SSE-C, today, offers little advantage over the alternatives. Because S3 doesn&apos;t keep the key, it has to be resent with every single request: sharing access to the data with other users or services becomes awkward, and it lacks the traceability KMS provides naturally through IAM and CloudTrail. Ever since KMS arrived - letting you create, own and manage keys with access controls and usage logging - the practical benefit of SSE-C has effectively thinned out, and most modern workloads have stopped using it.&lt;/p&gt;
&lt;p&gt;The change of default is therefore best read as a secure-by-default choice: turning off a rarely used feature reduces the &lt;a href=&quot;/en/changelog/bastion-host&quot;&gt;surface&lt;/a&gt; where configuration mistakes can arise, while still leaving those who genuinely need it the option to turn it back on.&lt;/p&gt;
&lt;h2&gt;What happens to anyone still using SSE-C&lt;/h2&gt;
&lt;p&gt;On a bucket where SSE-C is blocked, any request that explicitly asks for SSE-C is rejected with an HTTP 403 &lt;code&gt;AccessDenied&lt;/code&gt; error, in other words an &quot;access denied&quot;. This covers uploads (&lt;code&gt;PutObject&lt;/code&gt;), copies (&lt;code&gt;CopyObject&lt;/code&gt;), &lt;code&gt;PostObject&lt;/code&gt; requests, multipart uploads and cross-bucket replication.&lt;/p&gt;
&lt;p&gt;For an application that expects to write with SSE-C, this shows up as a sudden and potentially widespread failure. Hence the value of noticing it in advance, as a planned check rather than a production incident.&lt;/p&gt;
&lt;h2&gt;What to verify first&lt;/h2&gt;
&lt;p&gt;It helps to work through two questions, in order.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;First question: is SSE-C used anywhere?&lt;/strong&gt; It isn&apos;t always obvious, especially in automation written a while ago. To find out, you can look in CloudTrail at which encryption methods appear in requests to S3, and use S3 Inventory reports to list objects already encrypted with SSE-C. To check the encryption configuration of a single bucket, you can query the API with a read-only command:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;aws s3api get-bucket-encryption --bucket your-bucket-name
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;strong&gt;Second question: if SSE-C is genuinely needed, how do you turn it back on?&lt;/strong&gt; On a new bucket it has to be enabled explicitly by calling the &lt;code&gt;PutBucketEncryption&lt;/code&gt; API (which requires the &lt;code&gt;s3:PutEncryptionConfiguration&lt;/code&gt; permission), after which applications keep including the usual SSE-C headers in their requests. The same API also handles the bucket-level setting introduced for this change, which lets you block or unblock SSE-C in a controlled way, bucket by bucket.&lt;/p&gt;
&lt;p&gt;For anyone who discovers they still depend on SSE-C, this is also a good moment for a more fundamental question: does that data really need a key managed outside AWS, or would SSE-KMS cover the need while adding traceability and access controls? The answer varies case by case, but it&apos;s worth asking now, calmly, rather than in front of a failed upload.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;The operational message is simple. The change is already rolling out, was announced months ahead, and for most users is transparent, while nudging toward a more cautious default. For anyone who invested in SSE-C - often in pipelines or scripts no one has looked at in a while - the task is clear: find where SSE-C is in use, decide whether it still makes sense or whether switching to SSE-KMS is better, and where needed re-enable it explicitly on the right buckets before the updated default makes a write fail, exactly the way you&apos;d &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;test a restore&lt;/a&gt; before you actually need it.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to lock down your AWS infrastructure?&quot; text=&quot;We manage AWS cloud configuration: encryption, IAM permissions and monitoring, auditing your setup before any default change can break something.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://aws.amazon.com/about-aws/whats-new/2026/04/s3-default-bucket-security-setting/&quot;&gt;Amazon S3 starts rolling out new security best practice to new and existing buckets by default (AWS What&apos;s New)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/&quot;&gt;Advanced notice: Amazon S3 to disable the use of SSE-C encryption by default (AWS Storage Blog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-s3-c-encryption-setting-faq.html&quot;&gt;Default SSE-C setting for new buckets FAQ (Amazon S3 User Guide)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>TLS Encrypted Client Hello Becomes a Standard (RFC 9849)</title><link>https://initd.it/en/changelog/tls-encrypted-client-hello</link><guid isPermaLink="true">https://initd.it/en/changelog/tls-encrypted-client-hello</guid><description>RFC 9849 makes Encrypted Client Hello a standard: it hides the site name that used to be visible during the TLS handshake. What changes for privacy, reverse proxies, CDNs, and SNI-based filtering.</description><pubDate>Tue, 10 Mar 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;For years, anyone watching network traffic could read one detail that many people assumed was already protected: the name of the site you were connecting to. The connection was encrypted, the padlock in the browser was closed, and yet that piece of information traveled in the clear. In March 2026 the IETF, the body that writes Internet standards, published RFC 9849, titled &quot;TLS Encrypted Client Hello.&quot; The document closes exactly that gap. It&apos;s worth understanding what it really hides, and why it matters to anyone who designs reverse proxies, CDNs, and filtering systems.&lt;/p&gt;
&lt;h2&gt;The detail that stayed exposed&lt;/h2&gt;
&lt;p&gt;When a browser opens a secure connection to a site, the two sides first exchange a few messages to agree on keys and parameters. This phase is called the handshake. With the most recent version of the protocol, TLS 1.3, almost the entire handshake is encrypted: an outside observer just sees unreadable bytes go by.&lt;/p&gt;
&lt;p&gt;There was one important exception, though. In the very first message, the ClientHello, the browser has to say which site it wants to reach. That&apos;s necessary because a single IP address can host hundreds of different sites, and the server needs to know &lt;a href=&quot;/en/changelog/tls-certificates-47-days&quot;&gt;which certificate to present&lt;/a&gt;. This indication is called SNI, short for Server Name Indication, and until now it traveled in the clear. In practice, anyone along the path of the connection (a network operator, an ISP, a corporate firewall) could read &lt;code&gt;example.com&lt;/code&gt; without seeing any of the actual content. As the RFC itself puts it, the plaintext SNI is perhaps the most sensitive piece of information left exposed in TLS 1.3.&lt;/p&gt;
&lt;h2&gt;What Encrypted Client Hello is&lt;/h2&gt;
&lt;p&gt;Encrypted Client Hello, shortened to ECH, is a TLS 1.3 extension that encrypts the ClientHello, and with it the SNI. Not just the site name: it also protects other fields that could hint at the destination, such as the list of application protocols the client is willing to use (the ALPN extension).&lt;/p&gt;
&lt;p&gt;The idea isn&apos;t new. It grew out of years of work on an earlier proposal called ESNI, which encrypted only the site name. Over time it became clear that hiding a single field wasn&apos;t enough: other details in the ClientHello could give away the destination. The proposal was therefore redesigned to encrypt the whole message, and that&apos;s the version that reached standard status with RFC 9849. The document has Proposed Standard status, the first rung on the official IETF standards track: it&apos;s stable and published, no longer a draft.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your reverse proxy route traffic just by reading the SNI?&quot; text=&quot;We can check whether your setup still works once that name stops being readable.&quot; button=&quot;Request a review →&quot;}&lt;/p&gt;
&lt;h2&gt;How it works, without the jargon&lt;/h2&gt;
&lt;p&gt;The mechanism is built around two nested ClientHellos. There&apos;s an &quot;inner&quot; one, the real one, which carries the true SNI and gets encrypted. And there&apos;s an &quot;outer&quot; one, visible, which carries a public, innocuous name shared by many sites hosted behind the same operator.&lt;/p&gt;
&lt;p&gt;Anyone watching from outside sees only the public name. The server that receives the connection, called the client-facing server, decrypts the inner ClientHello, figures out which site was actually requested, and routes the connection accordingly. If many sites share the same public name, they become indistinguishable to an observer: that&apos;s what the spec calls an anonymity set.&lt;/p&gt;
&lt;p&gt;To encrypt the inner ClientHello, the client needs the &lt;a href=&quot;/en/changelog/wireguard-vpn&quot;&gt;server&apos;s public key&lt;/a&gt;. It obtains that key through DNS, the system that translates names into addresses. A companion document published alongside the first one, RFC 9848, defines how to publish this configuration (the ECHConfig) in DNS records of type SVCB and HTTPS, using a dedicated parameter called &lt;code&gt;ech&lt;/code&gt;. The encryption itself uses HPKE, a standard cryptographic scheme designed precisely for encrypting data toward a public key.&lt;/p&gt;
&lt;p&gt;The design also covers the cases where something doesn&apos;t line up. If the server can&apos;t decrypt, for example because the client used a configuration that has since expired, it can respond with an updated one and the connection is retried. And there&apos;s a trick called GREASE: clients can send fake ECH data even when they aren&apos;t really using it, so that ECH users don&apos;t stand out from the rest and network equipment doesn&apos;t &quot;get used to&quot; expecting a fixed format.&lt;/p&gt;
&lt;h2&gt;What changes for reverse proxies, CDNs, and filters&lt;/h2&gt;
&lt;p&gt;This is the practical part, the one that affects people who run infrastructure.&lt;/p&gt;
&lt;p&gt;Many &lt;a href=&quot;/en/changelog/nginx-reverse-proxy&quot;&gt;reverse proxies&lt;/a&gt; route connections by reading the SNI without even decrypting the traffic: they look at the name, pick the right backend, and pass it along. With ECH this no longer works, because the visible SNI is the shared public name. To route based on the real site, the exposed server has to become the client-facing server in full: decrypt the ECH and read the inner SNI. Anyone who built their routing on plaintext SNI alone will need to rethink the architecture.&lt;/p&gt;
&lt;p&gt;For CDNs the model fits well. A CDN already hosts many customers behind the same addresses: it can present a common public name, act as the client-facing server, and route to the correct site after decrypting the ECH. It&apos;s also the setting where the anonymity set is largest, and therefore where the protection is most effective.&lt;/p&gt;
&lt;p&gt;SNI-based filters are a different story. Firewalls, parental controls, corporate filters, and network-level blocking tools often decide what to let through by reading the site name in the SNI. With ECH that name is no longer visible: a filter that relies only on the SNI loses its foothold. It&apos;s the flip side of the privacy gain, and it&apos;s worth knowing about early, without assuming that nothing will change.&lt;/p&gt;
&lt;h2&gt;Where we stand&lt;/h2&gt;
&lt;p&gt;ECH is a published standard, but its effect depends on how widely both sides adopt it. On the client side, some browsers have already been experimenting with ECH for a while. On the server side, several CDNs offer it and cryptographic libraries are adding support: a few days after publication, the OpenSSL project announced support for ECH as described in RFC 9849.&lt;/p&gt;
&lt;p&gt;A few prerequisites are worth keeping in mind. ECH requires TLS 1.3, so connections that fall back to older versions stay exposed. And it depends on DNS to fetch the configuration: if DNS queries travel in the clear, an observer can still infer the destination or tamper with the configuration. That&apos;s why ECH mostly makes sense together with encrypted DNS, such as DNS over HTTPS or DNS over TLS.&lt;/p&gt;
&lt;p&gt;In short, RFC 9849 shields the last piece of the handshake that was still readable. It isn&apos;t a sudden revolution: it&apos;s a building block that becomes official after years of field testing, and one that over the coming months will quietly change how reverse proxies, CDNs, and network filters see, or no longer see, the names of the sites people visit.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Ready to get your infrastructure ready for ECH?&quot; text=&quot;We review reverse proxies, CDNs and filtering rules so traffic keeps routing correctly even once the SNI is encrypted.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/info/rfc9849/&quot;&gt;RFC 9849: TLS Encrypted Client Hello&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/info/rfc9848/&quot;&gt;RFC 9848: Bootstrapping TLS Encrypted ClientHello with DNS Service Bindings&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://datatracker.ietf.org/doc/rfc9849/&quot;&gt;RFC 9849 on the IETF Datatracker&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://openssl-library.org/post/2026-03-11-ech/&quot;&gt;The OpenSSL Library now supports Encrypted Client Hello (ECH)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Let&apos;s Encrypt: Six-Day Certificates and Certificates for IP Addresses</title><link>https://initd.it/en/changelog/lets-encrypt-6-day-ip-certificates</link><guid isPermaLink="true">https://initd.it/en/changelog/lets-encrypt-6-day-ip-certificates</guid><description>As of 15 January 2026 Let&apos;s Encrypt offers everyone certificates valid for just over six days and certificates for IP addresses. What they are, why they matter, and what changes for people running servers.</description><pubDate>Tue, 20 Jan 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone who runs a website knows TLS certificates: the small digital document that proves a server&apos;s identity and lets the browser encrypt the connection, the thing that lights up the padlock next to the address. Until recently a Let&apos;s Encrypt certificate lasted 90 days. As of 15 January 2026 the authority is making two new options available to everyone: certificates that expire after just over six days, and certificates that cover an IP address instead of a domain name. For people browsing, nothing changes. For people running servers it&apos;s a clear signal about where the web is heading: certificate lifetimes are shrinking, just as &lt;a href=&quot;/en/changelog/post-quantum-adoption&quot;&gt;the share of traffic already protected by post-quantum cryptography&lt;/a&gt; keeps growing, and automation is becoming the only sensible way to manage them.&lt;/p&gt;
&lt;h2&gt;The news in brief&lt;/h2&gt;
&lt;p&gt;Let&apos;s Encrypt is a &lt;strong&gt;Certificate Authority&lt;/strong&gt; (CA): the body that issues certificates, meaning it vouches for a site&apos;s identity. It&apos;s free, and for years it has been the most widely used CA in the world, because it turned issuing certificates into an automatic operation rather than a manual purchase.&lt;/p&gt;
&lt;p&gt;The two features being announced had been in limited testing for months. As of 15 January 2026 they&apos;ve moved to &lt;strong&gt;general availability&lt;/strong&gt;, meaning they&apos;re open to anyone:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Short-lived certificates&lt;/strong&gt;, valid for 160 hours, just over six days.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Certificates for IP addresses&lt;/strong&gt;, both IPv4 and IPv6.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Both remain optional. The standard Let&apos;s Encrypt certificate still lasts 90 days: if you do nothing, you&apos;ll notice no difference. If you want the short-lived certificates or the IP ones, you have to ask for them explicitly.&lt;/p&gt;
&lt;h2&gt;Six days instead of ninety&lt;/h2&gt;
&lt;p&gt;Getting a short-lived certificate takes more than simply asking for one: the program that talks to the authority has to be able to name a &lt;strong&gt;profile&lt;/strong&gt;, a kind of certificate template. The profile is called &lt;code&gt;shortlived&lt;/code&gt;. It&apos;s identical to the one normally used for websites, with a single difference: the certificate lasts about six days instead of three months.&lt;/p&gt;
&lt;p&gt;That very short lifetime isn&apos;t arbitrary. There&apos;s an industry rule, the &lt;em&gt;Baseline Requirements&lt;/em&gt;, which defines a separate category, &lt;strong&gt;short-lived certificates&lt;/strong&gt;. A certificate that falls into this category gets a privilege: it doesn&apos;t have to carry any revocation information. To see why that&apos;s an advantage, we need to step back and explain what revocation is.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Are the certificates on your server still renewed by hand?&quot; text=&quot;We check the ACME client you&apos;re running and its compatibility with short-lived profiles, before they become the default.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;Why so short: the revocation problem&lt;/h2&gt;
&lt;p&gt;Every certificate is tied to a &lt;strong&gt;private key&lt;/strong&gt;, a secret file that must stay on the server and never leave it. If that key is stolen - through an attack, a misconfiguration, a backup ending up in the wrong place - whoever holds it can impersonate the legitimate site for as long as the certificate stays valid. This interval is called the &lt;strong&gt;window of compromise&lt;/strong&gt;: the longer the certificate, the longer a theft can do damage without anyone noticing.&lt;/p&gt;
&lt;p&gt;In theory there&apos;s a remedy: &lt;strong&gt;revocation&lt;/strong&gt;, declaring a certificate invalid before its natural expiry. In practice revocation works poorly. Browsers don&apos;t always check whether a certificate has been revoked, and the mechanisms meant to warn them are slow or unreliable. The result is that, even after a revocation, many visitors keep trusting a certificate they should no longer accept.&lt;/p&gt;
&lt;p&gt;Short-lived certificates sidestep the problem at its root. If a certificate lasts six days, the window of compromise is six days at most: after that, it expires on its own. There&apos;s no need to revoke it, because it disappears quickly anyway. It&apos;s a less elegant but more solid way to reach the same result. It&apos;s also why Let&apos;s Encrypt has said it plans to bring the standard lifetime down from today&apos;s 90 days to 45 over the coming years, the same industry-wide shift set out by &lt;a href=&quot;/en/changelog/tls-certificates-47-days&quot;&gt;the CA/Browser Forum&apos;s 47-day target&lt;/a&gt;: the direction is to shrink the time in which a mistake can do harm.&lt;/p&gt;
&lt;h2&gt;The end of OCSP&lt;/h2&gt;
&lt;p&gt;This choice is tied to a change that happened a few months earlier. For years the main way to check whether a certificate had been revoked was called &lt;strong&gt;OCSP&lt;/strong&gt; (Online Certificate Status Protocol): on each visit, software could ask the authority in real time, &quot;is this certificate still valid?&quot;.&lt;/p&gt;
&lt;p&gt;On 6 August 2025 Let&apos;s Encrypt switched off its OCSP service. There were two reasons. The first is privacy: every OCSP query revealed to the authority which site a person was visiting, and from which address. The second is scale: at its peak the service handled around 340 billion requests a month, an enormous infrastructure to maintain. In place of OCSP, one mechanism remains, &lt;strong&gt;CRLs&lt;/strong&gt; (Certificate Revocation Lists), that is, lists of revoked certificates published periodically.&lt;/p&gt;
&lt;p&gt;In a world where real-time checking no longer exists, short-lived certificates make even more sense: they don&apos;t need to be revoked, so they don&apos;t depend on a revocation system that has deliberately been made lighter.&lt;/p&gt;
&lt;h2&gt;Certificates for an IP address&lt;/h2&gt;
&lt;p&gt;The second new feature solves a different problem. Usually a certificate covers a &lt;strong&gt;domain name&lt;/strong&gt;, for example &lt;code&gt;example.com&lt;/code&gt;. But not everything has a domain: some services are reachable only through their numeric address, such as &lt;code&gt;203.0.113.10&lt;/code&gt; or an IPv6 address. Until now, for those cases, a publicly trusted certificate simply wasn&apos;t available, leaving only self-issued certificates, which browsers flag as untrusted.&lt;/p&gt;
&lt;p&gt;Now Let&apos;s Encrypt can issue certificates that cover an IP address directly, both IPv4 and IPv6. This protects connections to services that have no domain name: infrastructure endpoints, network appliances, technical environments where the numeric address is all there is.&lt;/p&gt;
&lt;p&gt;There are two constraints, both stemming from the nature of IP addresses. First: a certificate for an IP address &lt;strong&gt;must&lt;/strong&gt; be short-lived, so it goes through the &lt;code&gt;shortlived&lt;/code&gt; profile. The reason is that an IP address changes hands far more often than a domain, and checking it frequently matters to keep it from ending up with someone who shouldn&apos;t have it. Second: to prove control of the address you can use only two verification methods, one based on an HTTP response and one based on the TLS connection itself. The DNS-based method, handy for domains, can&apos;t be used here, because an IP address has no DNS records to edit.&lt;/p&gt;
&lt;h2&gt;What you need to use them&lt;/h2&gt;
&lt;p&gt;The practical requirement is just one: the program that manages your certificates - the &lt;strong&gt;ACME client&lt;/strong&gt;, where ACME is the standard protocol a server uses to obtain and renew certificates on its own - has to be able to request a profile. That&apos;s a recent feature, so it&apos;s worth running an up-to-date version of your client. The most common clients, including &lt;code&gt;certbot&lt;/code&gt;, already have dedicated instructions for selecting the &lt;code&gt;shortlived&lt;/code&gt; profile.&lt;/p&gt;
&lt;p&gt;The rest is automation, and that&apos;s the important part. A certificate that lasts six days has to be renewed every few days: by hand it&apos;s unthinkable. But for an automated system, renewing every day or every three days is no more effort than renewing every two months. If you already leave renewals to an ACME client that runs on its own, you have almost nothing to change; if you still renew by hand, with these certificates you simply can&apos;t.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Let&apos;s Encrypt has opened two optional features to everyone: certificates valid for just over six days and certificates for IP addresses. The first shrink to a minimum the time in which a compromised certificate can do harm, in a world where revocation - and the old OCSP service, now switched off - offered no reliable guarantees. The second bring publicly trusted certificates to places where there&apos;s no domain. The common thread is the same throughout: shorter certificates, more frequent checks, and solid automation as the one condition for keeping up, while over the same period &lt;a href=&quot;/en/changelog/chrome-post-quantum-tls&quot;&gt;post-quantum key exchange turned on by default in Chrome&lt;/a&gt; is raising the bar for TLS security more broadly.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to really automate renewal of your TLS certificates?&quot; text=&quot;We set up ACME clients, automatic renewal and expiry monitoring on your servers, from classic domains to IP addresses exposed with no domain name.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://letsencrypt.org/2026/01/15/6day-and-ip-general-availability/&quot;&gt;6-day and IP Address Certificates are Generally Available - Let&apos;s Encrypt&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://letsencrypt.org/2025/08/06/ocsp-service-has-reached-end-of-life&quot;&gt;OCSP Service Has Reached End of Life - Let&apos;s Encrypt&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://letsencrypt.org/2025/01/16/6-day-and-ip-certs&quot;&gt;Announcing Six Day and IP Address Certificate Options in 2025 - Let&apos;s Encrypt&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>The 3-2-1 Backup Rule Explained (and Why It Works)</title><link>https://initd.it/en/changelog/backup-3-2-1</link><guid isPermaLink="true">https://initd.it/en/changelog/backup-3-2-1</guid><description>What the 3-2-1 rule means - three copies, two media, one offsite - why it lowers the risk of losing data, why restores must be tested, and what RPO and RTO really are, in plain words.</description><pubDate>Thu, 11 Dec 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Sooner or later it happens to everyone: a drive that stops spinning, a file deleted by mistake, a phone dropped in water, a business frozen by a cyberattack. In those moments the question is always the same: &quot;Is there a copy somewhere?&quot; The 3-2-1 rule is the simplest, most proven answer to that question. It isn&apos;t a product or a technology: it&apos;s a way of thinking about backups that works just as well for a photographer with their photos as for a company with its business software.&lt;/p&gt;
&lt;p&gt;The starting point is an uncomfortable but healthy idea: sooner or later something will be lost. That&apos;s not pessimism, it&apos;s statistics. Drives fail, people make mistakes, software has bugs, thieves exist. A backup isn&apos;t there to stop that from happening. It&apos;s there to make sure that when it does, it isn&apos;t a disaster.&lt;/p&gt;
&lt;h2&gt;What the 3-2-1 rule says&lt;/h2&gt;
&lt;p&gt;The rule boils down to three numbers.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;3 copies&lt;/strong&gt; of your data. The original plus two more copies. &quot;Having a backup&quot; isn&apos;t enough: you want at least two, on top of the data you use every day.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;2 different media.&lt;/strong&gt; The copies shouldn&apos;t all sit on the same kind of device. For example: your computer&apos;s drive and an external disk, or a local disk and a cloud service.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;1 copy offsite.&lt;/strong&gt; At least one copy should live in a physically different place: another building, a data center, the cloud. Away from the risks that threaten the original.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Put like that, it sounds obvious. The value is in &lt;em&gt;why&lt;/em&gt; each of those numbers is there.&lt;/p&gt;
&lt;h2&gt;Why three copies and not one&lt;/h2&gt;
&lt;p&gt;A single backup, kept right next to the original, protects against very little. If I delete a file by mistake and notice right away, fine. But if the backup lives on the same disk as the original, one drive failure takes both at once. If it&apos;s in the same room, a theft or a flood does the same.&lt;/p&gt;
&lt;p&gt;Three copies make it unlikely that a single event wipes out all of them. It&apos;s the same reason you don&apos;t keep all your cash in one place. The more independent the copies are from one another - that&apos;s what engineers call redundancy - the less likely you are to lose them together.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do you actually know your backups restore, or are you just hoping?&quot; text=&quot;We review your current backup strategy: how many copies, on which media, and whether restores have ever really been tested.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;Why two different media&lt;/h2&gt;
&lt;p&gt;Every kind of storage has its own weak spots. A mechanical drive can wear out and break. A USB stick can be lost. An online service can have an outage or an account problem. Using two different types of media keeps the same flaw from hitting every copy.&lt;/p&gt;
&lt;p&gt;A classic example: one copy on an external disk in the office and one copy in a cloud service. The two media share almost no risks. The lightning strike that fries the electronics in the office doesn&apos;t touch the cloud; the connection problem that blocks the cloud doesn&apos;t stop you reading the external disk.&lt;/p&gt;
&lt;h2&gt;Why one copy offsite&lt;/h2&gt;
&lt;p&gt;The first two rules protect against failures. The third protects against disasters that hit an entire place: a fire, a flood, a theft - but also a cyberattack that encrypts or wipes everything it can reach over the network.&lt;/p&gt;
&lt;p&gt;&quot;Offsite&quot; means exactly that: a copy that isn&apos;t in the same place as the rest of your data and, ideally, can&apos;t be reached with the same credentials, a requirement that squarely falls under the &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;security measures required under GDPR&lt;/a&gt; on the infrastructure side. If a fire destroys the office, the copy in a data center on the other side of the country is still there. If an attacker gets into the systems, a copy that&apos;s isolated and can&apos;t be changed is the last line of defense, the same principle behind &lt;a href=&quot;/en/changelog/aws-s3-sse-c-default&quot;&gt;encryption keys that not even the cloud provider can read&lt;/a&gt; without the customer&apos;s consent.&lt;/p&gt;
&lt;h2&gt;The backup nobody tests&lt;/h2&gt;
&lt;p&gt;There&apos;s a mistake that shows up again and again: taking backups for years and never actually trying to bring them back. A backup that has never been restored isn&apos;t a backup - it&apos;s a hope.&lt;/p&gt;
&lt;p&gt;The reasons a restore can fail are many and mundane. The backup file is corrupt. The job, maybe &lt;a href=&quot;/en/changelog/systemd-timers&quot;&gt;scheduled with a timer&lt;/a&gt;, was saving the wrong folder. The password to open the encrypted archive is gone. The format isn&apos;t readable anymore. All things you only find out by trying - and the worst time to find out is during a real emergency.&lt;/p&gt;
&lt;p&gt;That&apos;s why the restore test is part of the rule, not an extra. Restoring a copy every so often into a separate environment and checking that the data is really there is the only way to know the backup works. If it hasn&apos;t been tested, you don&apos;t know it works: you&apos;re hoping. It&apos;s also the first requirement of any major infrastructure change, such as &lt;a href=&quot;/en/changelog/proxmox-8-end-of-life-upgrade&quot;&gt;upgrading a Proxmox hypervisor that is leaving support&lt;/a&gt;: before touching the server, you make sure the way back actually exists. It also applies to companies subject to NIS2: ACN&apos;s baseline measures ask for verified backups of data and configurations and, for relevant systems, offline copies too, as we explain in &lt;a href=&quot;/en/changelog/nis2-suppliers-what-to-prepare&quot;&gt;NIS2 and suppliers&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;RPO and RTO in plain words&lt;/h2&gt;
&lt;p&gt;When people talk about serious backups, two acronyms show up: RPO and RTO. They sound complicated, but behind them are two very concrete questions.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;RPO&lt;/strong&gt; stands for Recovery Point Objective. It answers the question: &quot;How much data can I afford to lose?&quot; In practice it&apos;s how often you take a backup. If I save once a day, in the worst case I can lose up to a day&apos;s work: everything that changed since the last backup. If that&apos;s too much, the answer is to back up more often. NIST - the U.S. body that publishes technical standards - defines it as the point in time to which data must be recovered after an outage.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;RTO&lt;/strong&gt; stands for Recovery Time Objective. It answers the other question: &quot;How long can I stay down?&quot; It&apos;s how much time can pass between the failure and getting back to normal. A personal site can be down for a few hours without much harm; an online shop during a sale weekend cannot, not too different from the reasoning behind choosing a &lt;a href=&quot;/en/changelog/aws-aurora-dsql&quot;&gt;highly available database&lt;/a&gt; for the most critical services. NIST describes it as the overall length of time systems can be in recovery before the impact on the organization becomes unacceptable.&lt;/p&gt;
&lt;p&gt;The two acronyms measure two different losses: RPO measures lost data, RTO measures lost time. Deciding them in advance helps you choose: how often to back up, and how quickly you need to be able to restore. Everything else follows from there.&lt;/p&gt;
&lt;h2&gt;Where the rule comes from&lt;/h2&gt;
&lt;p&gt;The &quot;3-2-1&quot; formula was popularized by photographer Peter Krogh in the mid-2000s, in his book &lt;em&gt;The DAM Book&lt;/em&gt; on managing digital archives. Krogh didn&apos;t invent the idea of multiple copies and an offsite copy - it already existed - but he distilled it into three easy-to-remember numbers. Since then it has become a common reference, echoed even by public agencies that deal with cybersecurity.&lt;/p&gt;
&lt;h2&gt;It&apos;s not a dogma&lt;/h2&gt;
&lt;p&gt;3-2-1 is a good starting point, not a finish line. In recent years, as &lt;em&gt;ransomware&lt;/em&gt; attacks have spread - the programs that encrypt your data and demand a ransom - variants have emerged that stress two extra points: keep at least one copy that is immutable or air-gapped from the network, so an attacker can&apos;t delete it, and verify that restores run without errors. These are refinements, not upheavals: the core stays the same.&lt;/p&gt;
&lt;p&gt;The reverse is true too. Home data doesn&apos;t need a corporate plan: two copies on different media and one in the cloud already cover most of the risks. The rule scales up and down.&lt;/p&gt;
&lt;h2&gt;In summary&lt;/h2&gt;
&lt;p&gt;The 3-2-1 rule works because it attacks the right problem: not &quot;how to avoid failures&quot; but &quot;how to survive when they happen.&quot; Three copies make it unlikely you lose them all at once; two different media keep the same flaw from hitting all of them; one offsite copy survives the disasters that erase a whole place. And none of it counts if you never try to restore. Defining how much you can lose (RPO) and how long you can be down (RTO) turns a good habit into a plan. You don&apos;t need to be an expert - you just need to take seriously the idea that, sooner or later, a copy will actually be needed.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want a 3-2-1 backup strategy that actually works?&quot; text=&quot;We design and manage automated backups, offsite copies and periodic restore tests for Linux systems and our clients&apos; applications.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://csrc.nist.gov/glossary/term/recovery_point_objective&quot;&gt;NIST - Recovery Point Objective (CSRC glossary)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://csrc.nist.gov/glossary/term/recovery_time_objective&quot;&gt;NIST - Recovery Time Objective (CSRC glossary)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://en.wikipedia.org/wiki/Backup&quot;&gt;Wikipedia - Backup (the 3-2-1 rule)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.backupwrapup.com/peter-krogh-who-coined-the-3-2-1-rule-on-our-podcast/&quot;&gt;Backup Wrap-Up - Peter Krogh and the origin of the 3-2-1 rule&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Amazon S3 Vectors: similarity search without a dedicated database</title><link>https://initd.it/en/changelog/aws-s3-vectors</link><guid isPermaLink="true">https://initd.it/en/changelog/aws-s3-vectors</guid><description>Amazon S3 Vectors is now generally available: AWS object storage can now store and query vectors for semantic search and RAG, aiming to cut cost and complexity compared with a dedicated vector database.</description><pubDate>Tue, 09 Dec 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;When you search an archive, you usually search for exact words: type &quot;invoice&quot; and you get the documents that contain the word &quot;invoice&quot;, not the ones that talk about a &quot;receipt&quot; or a &quot;payment note&quot;. Applications built on artificial intelligence need a different kind of search: finding content that is &lt;em&gt;similar in meaning&lt;/em&gt;, even when the words differ. Doing that requires a way of storing and comparing data called a vector database. On 2 December 2025, at the re:Invent conference, AWS made Amazon S3 Vectors generally available - meaning it left the restricted preview and opened to everyone - bringing this capability into S3, its most widely used storage service.&lt;/p&gt;
&lt;h2&gt;What vectors are and why they matter&lt;/h2&gt;
&lt;p&gt;To make sense of the announcement, start with vectors, or &lt;em&gt;embeddings&lt;/em&gt;. An embedding is a list of numbers that represents the meaning of a piece of content: a sentence, a document, an image. It&apos;s produced by an AI model that turns text or an image into a long sequence of figures. The core idea is simple: two pieces of content that are similar in meaning produce &quot;nearby&quot; vectors, while two pieces about different things produce &quot;distant&quot; ones. Nearness is measured with a geometric calculation, like the distance between two points.&lt;/p&gt;
&lt;p&gt;With this trick, searching becomes a different operation. Instead of comparing words, you compare numbers: you take the user&apos;s question, turn it into its vector, and look for the closest vectors in the archive. The result is &lt;strong&gt;semantic search&lt;/strong&gt;, that is, search by meaning. Someone asking &quot;how do I protect the server from unauthorised access&quot; can get a document titled &quot;SSH hardening&quot;, even though it contains none of the words they typed.&lt;/p&gt;
&lt;h2&gt;The link to AI: RAG&lt;/h2&gt;
&lt;p&gt;This mechanism is at the heart of a technique widely used with language models, &lt;strong&gt;RAG&lt;/strong&gt; (Retrieval Augmented Generation). A model like the ones behind conversational assistants knows a lot in general, but it doesn&apos;t know a company&apos;s internal documents or information that&apos;s current as of yesterday. RAG fills that gap: before answering, the system searches its own archives for the passages most relevant to the question - using exactly this similarity search over vectors - and passes them to the model &lt;a href=&quot;/en/changelog/what-is-mcp&quot;&gt;as context&lt;/a&gt;. That way the answer rests on real, checkable documents, not only on what the model learned during training.&lt;/p&gt;
&lt;p&gt;To do all this you need two things: somewhere to store the vectors, and a fast way to find the ones closest to a reference vector. That&apos;s the job of a &lt;strong&gt;vector database&lt;/strong&gt;. Until recently it meant adopting specialised software to install and maintain, or a separate dedicated service, with a cost that grows along with the number of vectors.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Want an assistant that can answer using your internal documents?&quot; text=&quot;We assess whether a RAG setup with semantic search fits your use case, and at what real cost.&quot; button=&quot;Ask for an assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;What changes by putting vectors inside S3&lt;/h2&gt;
&lt;p&gt;Amazon S3 is AWS&apos;s object storage: a place to drop files of every kind - images, backups, logs, documents - paying little for large amounts of space. It&apos;s one of the most common building blocks of cloud infrastructure, the same service that also manages &lt;a href=&quot;/en/changelog/aws-s3-sse-c-default&quot;&gt;server-side encryption settings&lt;/a&gt;. The idea behind S3 Vectors is to add to that storage the ability to hold vectors and search them by similarity, without a separate database alongside it.&lt;/p&gt;
&lt;p&gt;In practice you create a &lt;strong&gt;vector bucket&lt;/strong&gt;, a container similar to an ordinary S3 bucket but designed for vectors, and inside it one or more &lt;strong&gt;vector indexes&lt;/strong&gt;. When you create an index you declare a few things: the &lt;em&gt;dimension&lt;/em&gt; of the vectors, that is, how many numbers each one contains, and the &lt;em&gt;distance metric&lt;/em&gt; used to measure nearness, which can be cosine or euclidean. Each vector can carry metadata - extra information such as the date or the source of the document, handy for filtering results: up to 50 metadata keys per vector.&lt;/p&gt;
&lt;p&gt;The service is &lt;strong&gt;serverless&lt;/strong&gt;, much like other AWS &lt;a href=&quot;/en/changelog/aws-aurora-dsql&quot;&gt;serverless databases&lt;/a&gt;. &quot;Serverless&quot; doesn&apos;t mean there are no servers; it means the people using the service don&apos;t have to choose, size or update them: AWS handles that. There&apos;s no cluster to keep running and pay for by the hour: you pay for the space the vectors take up and for the write and query operations actually performed.&lt;/p&gt;
&lt;p&gt;The benefit AWS puts front and centre is cost. The official estimate is a reduction of up to 90% in the total cost to upload, store and query vectors compared with dedicated vector database solutions. That&apos;s a figure stated by the provider, and, as always, the real saving depends on how the service is used; but it signals the direction: making similarity search an affordable option even for very large archives.&lt;/p&gt;
&lt;h2&gt;How far it scales, and its limits&lt;/h2&gt;
&lt;p&gt;General availability arrives with higher numbers than the preview. Each index can hold up to &lt;strong&gt;2 billion vectors&lt;/strong&gt;, forty times the preview limit of 50 million, and each vector bucket can host up to &lt;strong&gt;10,000 indexes&lt;/strong&gt;. These figures move the service from demo territory to production use over large document collections.&lt;/p&gt;
&lt;p&gt;On response times, AWS states that infrequent queries return a result in under a second, while frequent ones drop to around 100 milliseconds or less. Each query can return up to 100 results (it was 30 in preview), and writes reach up to 1,000 vectors per second when updating indexes one vector at a time.&lt;/p&gt;
&lt;p&gt;It&apos;s worth being honest about the trade-off. S3 Vectors is built to be cheap and to hold enormous volumes, not to be the fastest option outright: a hundred milliseconds is fine for a document archive, less so for scenarios that need answers in a few milliseconds under heavy traffic. Tellingly, AWS also presents it paired with OpenSearch, its search engine: you can keep the rarely used, cheaper vectors in S3 Vectors and move only the ones that need top performance over to OpenSearch.&lt;/p&gt;
&lt;h2&gt;The integrations&lt;/h2&gt;
&lt;p&gt;General availability also stabilises some useful integrations. S3 Vectors connects to &lt;strong&gt;Amazon Bedrock Knowledge Bases&lt;/strong&gt;, the service AWS uses to build RAG applications: you can use S3 Vectors as the vector store to lower the cost of an assistant that answers by drawing on a document base. The integration with &lt;strong&gt;Amazon OpenSearch&lt;/strong&gt; is available too, for the two-tier architecture described above. There&apos;s also support for &lt;strong&gt;CloudFormation&lt;/strong&gt;, to create resources automatically and repeatably, &lt;strong&gt;PrivateLink&lt;/strong&gt; for private-network connectivity, a dedicated encryption key per individual index, and tags for access control and cost allocation.&lt;/p&gt;
&lt;p&gt;As of the announcement the service is live in 14 AWS Regions, up from 5 in preview, including Ireland, London, Paris, Frankfurt and Stockholm in Europe.&lt;/p&gt;
&lt;h2&gt;Where it fits&lt;/h2&gt;
&lt;p&gt;S3 Vectors is a good option when there are many vectors, queries aren&apos;t constant, and cost matters more than minimal latency: documentation archives, &lt;a href=&quot;/en/changelog/agent-skills&quot;&gt;knowledge bases for internal assistants&lt;/a&gt;, semantic search over catalogues. In these cases it avoids installing, updating and paying for a separate vector database, and keeps the vectors close to data that is often already on S3.&lt;/p&gt;
&lt;p&gt;The opposite reasoning holds just as well. If an application needs answers in the order of a few milliseconds over a steady stream of requests, or advanced features offered by a specialised engine, a dedicated vector database - or the pairing with OpenSearch - remains the better fit. As always, the choice depends on concrete requirements of volume, frequency and speed, not on the novelty itself.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to build an AI assistant that knows your company&apos;s documents?&quot; text=&quot;We design custom RAG pipelines, from choosing the vector store to integrating it into your Laravel and Vue applications, with an eye on cost and data security.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://aws.amazon.com/blogs/aws/amazon-s3-vectors-now-generally-available-with-increased-scale-and-performance/&quot;&gt;Amazon S3 Vectors now generally available with increased scale and performance (AWS News Blog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://aws.amazon.com/about-aws/whats-new/2025/12/amazon-s3-vectors-generally-available/&quot;&gt;Amazon S3 Vectors is now generally available with 40 times the scale of preview (AWS What&apos;s New)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>MCP Moves to the Linux Foundation: An Open, Neutral Standard</title><link>https://initd.it/en/changelog/mcp-linux-foundation</link><guid isPermaLink="true">https://initd.it/en/changelog/mcp-linux-foundation</guid><description>The Model Context Protocol, the standard for connecting AI apps to external tools, has been donated to an independent foundation under the Linux Foundation. What it means and why it matters for anyone building on it.</description><pubDate>Mon, 08 Dec 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;More and more AI programs don&apos;t just answer questions: they read files, query databases, and use external tools on behalf of the people using them, the way &lt;a href=&quot;/en/changelog/gemini-cli&quot;&gt;an AI assistant that lives in the terminal&lt;/a&gt; now does too. For all of this to work, there needs to be a common way to connect those programs to the systems they have to talk to. One of the most widely used standards for that is called MCP. In early December 2025 a change was announced: MCP is no longer governed by a single company but has moved under an independent foundation. The news mainly concerns people who build software on top of the standard, but it&apos;s worth understanding from the outside too, because it touches a simple question: who do you trust when you pick a technology to build your work on.&lt;/p&gt;
&lt;h2&gt;What MCP is&lt;/h2&gt;
&lt;p&gt;Let&apos;s start with the terms. &lt;strong&gt;MCP&lt;/strong&gt; stands for &lt;em&gt;Model Context Protocol&lt;/em&gt;. A &lt;strong&gt;protocol&lt;/strong&gt; is a set of shared rules that lets two programs talk to each other, a bit like a common language. MCP defines a standard way to connect AI applications - say an assistant like ChatGPT or Claude - to external systems: documents, databases, work tools, online services.&lt;/p&gt;
&lt;p&gt;The problem it addresses is concrete. Without a shared standard, every time you want a model to talk to a new tool, you have to write a custom connection. With many models on one side and many tools on the other, the number of integrations to build and maintain grows fast. A common protocol cuts that work down: whoever builds a tool exposes it once following MCP&apos;s rules, and any application that &quot;speaks&quot; MCP can use it without a dedicated integration. The idea is like a standard socket such as USB: one type of connector instead of many incompatible cables.&lt;/p&gt;
&lt;p&gt;&lt;a href=&quot;/en/changelog/what-is-mcp&quot;&gt;MCP is about a year old&lt;/a&gt; and has spread quickly. According to figures reported in the announcement, the developer packages (the libraries used to integrate the protocol) exceed 97 million downloads a month, and there are more than 10,000 active public MCP servers - that is, tools ready to plug in. Support is present in several widely used products, including ChatGPT, Claude, Cursor, &lt;a href=&quot;/en/changelog/gemini-3&quot;&gt;Gemini&lt;/a&gt;, Microsoft Copilot, and Visual Studio Code. These are numbers stated by the parties promoting the standard, so best treated as orders of magnitude rather than exact measures; they still signal broad adoption.&lt;/p&gt;
&lt;h2&gt;What happened&lt;/h2&gt;
&lt;p&gt;The change concerns &lt;strong&gt;governance&lt;/strong&gt;, meaning who decides how the standard evolves. Until now MCP was led by Anthropic, the company that created it. With the December announcement, the protocol was donated to the &lt;strong&gt;Agentic AI Foundation&lt;/strong&gt; (AAIF), a new effort hosted by the &lt;strong&gt;Linux Foundation&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;The Linux Foundation is a non-profit organization that acts as a steward for many open, widely used technology projects; among them are the Linux kernel, Kubernetes, and PyTorch. &quot;Hosting&quot; a project means putting a neutral structure around it, with shared rules, that doesn&apos;t belong to any single vendor.&lt;/p&gt;
&lt;p&gt;The Agentic AI Foundation is set up to help technologies around &lt;strong&gt;agents&lt;/strong&gt; grow in an open, collaborative way - agents being AI programs that, beyond answering, take concrete actions using external tools. It&apos;s co-founded by Anthropic, Block, and OpenAI, with support from Google, Microsoft, AWS, Cloudflare, and Bloomberg. It launches with three founding projects: MCP, donated by Anthropic; &lt;strong&gt;goose&lt;/strong&gt;, a project from Block; and &lt;strong&gt;AGENTS.md&lt;/strong&gt;, a convention proposed by OpenAI. The fact that companies that often compete with each other are contributing to the same foundation is, in itself, part of the story, in the same vein as other attempts to give shared rules to how AI agents get instructed, such as &lt;a href=&quot;/en/changelog/agent-skills&quot;&gt;Anthropic&apos;s Agent Skills&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Thinking about connecting your systems to an AI assistant through MCP?&quot; text=&quot;We review which data and tools are safe to expose, and which should stay out of an agent&apos;s reach.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;Why a neutral foundation matters&lt;/h2&gt;
&lt;p&gt;This is where the practical point of the announcement sits. When a standard is controlled by a single company, whoever builds on it depends on that company&apos;s choices: its priorities, its business model, its strategy. If those changed one day, the standard could follow. That worry holds back many adoptions, especially for infrastructure meant to last.&lt;/p&gt;
&lt;p&gt;Handing the standard to a neutral foundation shifts the center of gravity. Decisions no longer answer to a single owner but to a shared structure in which multiple parties have a voice. It&apos;s not an absolute guarantee, but it lowers the risk of the standard being bent to serve just one interest. It&apos;s the same path already taken by projects like Kubernetes and PyTorch, which became common references under the Linux Foundation precisely because no vendor holds exclusive control.&lt;/p&gt;
&lt;p&gt;For anyone weighing whether to invest time and code in MCP, this move is relevant. A foundational technology - the kind other tools rest on - is valuable above all for its stability and for the confidence it inspires over the long run. Governance that isn&apos;t tied to a single vendor makes the promise more credible: that the standard will stay open and supported in the future too.&lt;/p&gt;
&lt;h2&gt;What changes (and what doesn&apos;t) right now&lt;/h2&gt;
&lt;p&gt;For those already using MCP, little changes on the technical side in the short term. According to the announcement, the governance model introduced earlier continues as it was: decisions about the protocol stay with the same people who look after it, the &lt;strong&gt;maintainers&lt;/strong&gt; - those who keep the project going and evolve it - guided by community input through the process used to propose and discuss changes. Day-to-day development continues uninterrupted. Anthropic, for its part, says it will keep investing in development, maintain core infrastructure, and take part in the community.&lt;/p&gt;
&lt;p&gt;In practice, the change is more about form than technical substance: the standard stays the same, what changes is the house that hosts it and the rules of whoever decides its future. That&apos;s exactly the point of the news. There&apos;s no new version of the protocol to adopt and no API to rewrite; there&apos;s a different governing framework, designed to offer stronger guarantees of neutrality.&lt;/p&gt;
&lt;h2&gt;What remains to be seen&lt;/h2&gt;
&lt;p&gt;A few caveats are in order, without playing down the announcement. Moving to a foundation is a commitment of direction, not a done deal: the stated neutrality will have to be measured over time, by looking at how concrete decisions get made and how much the community can actually influence them. Having many companies around the same table is a positive sign, but governing a shared standard takes constant balance.&lt;/p&gt;
&lt;p&gt;There&apos;s also a broader point. MCP is a young, evolving standard: anyone adopting it does well to follow its updates and not treat everything available today as final. Moving under the Linux Foundation doesn&apos;t freeze the protocol; it hands it to a structure meant to help it mature in the open.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;MCP is the standard that lets AI applications connect uniformly to external tools and systems. With the early-December 2025 announcement it was donated to the Agentic AI Foundation, a new foundation under the Linux Foundation, alongside two other founding projects and with backing from several companies in the field. On the technical side little changes: the same maintainers keep looking after it and development goes on. What changes is governance, moving from a single company to a neutral structure. For people building on top of MCP that&apos;s the difference that matters most: an open standard not tied to a single vendor is easier to adopt with confidence. A step in the right direction, whose durability will remain to be checked over time.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to bring AI into your business workflows with judgment?&quot; text=&quot;We build custom MCP integrations for your Laravel software, weighing access security and costs before anything goes into production.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation&quot;&gt;Donating the Model Context Protocol and establishing the Agentic AI Foundation - Anthropic&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation&quot;&gt;Linux Foundation Announces the Formation of the Agentic AI Foundation (AAIF) - Linux Foundation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/&quot;&gt;MCP joins the Agentic AI Foundation - Model Context Protocol Blog&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Google Unveils Gemini 3: What Changes for Developers</title><link>https://initd.it/en/changelog/gemini-3</link><guid isPermaLink="true">https://initd.it/en/changelog/gemini-3</guid><description>Google has announced Gemini 3, its new flagship model. What actually improves in reasoning, coding, and multimodal work, and why it matters for anyone evaluating models for agents and automation.</description><pubDate>Tue, 18 Nov 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;People who build software or set up automations find themselves, every few months, facing a new AI model billed as the most capable ever. On November 18, 2025, Google announced Gemini 3, the new generation of its model family. It&apos;s worth looking past the headline: what actually improves, for which uses, and with what caveats. This article tries to sum up the announcement soberly, separating stated facts from marketing promises.&lt;/p&gt;
&lt;h2&gt;What Gemini 3 is&lt;/h2&gt;
&lt;p&gt;Let&apos;s start with the terms. &lt;strong&gt;Gemini&lt;/strong&gt; is Google&apos;s family of AI models, the one that powers the Gemini app, some Search features, and various tools for people who code. Gemini 3 is the new generation, taking over from the previous one (Gemini 2.5) as the flagship.&lt;/p&gt;
&lt;p&gt;At the center of the launch is &lt;strong&gt;Gemini 3 Pro&lt;/strong&gt;, available right away in preview. It&apos;s a &lt;strong&gt;multimodal&lt;/strong&gt; model: that means it can understand text, images, video, audio, and code within the same request, without handling them separately. It has a &lt;strong&gt;context window&lt;/strong&gt; of about one million tokens. A &lt;em&gt;token&lt;/em&gt; is a small chunk of text, roughly a syllable or a short word; the context window is how much material the model can keep in mind within a single conversation. One million tokens is a lot: it lets you hand over entire projects or long documents without splitting them by hand. The reply, on the other hand, can run up to about 65,000 tokens.&lt;/p&gt;
&lt;p&gt;Alongside the main model, Google announced &lt;strong&gt;Gemini 3 Deep Think&lt;/strong&gt;, a mode built for the hardest reasoning problems. At the time of the announcement it wasn&apos;t yet broadly available: it&apos;s aimed initially at Ultra plan subscribers. That&apos;s worth noting, because an announced feature isn&apos;t a feature you can already use.&lt;/p&gt;
&lt;h2&gt;The stated improvements&lt;/h2&gt;
&lt;p&gt;Google says Gemini 3 Pro beats the previous model on the main &lt;strong&gt;benchmarks&lt;/strong&gt;, the standardized tests used to measure models. A few numbers are worth reporting, but with due caution: these are figures stated by the party selling the product, each one measures only a slice of the real work, and none tells the whole story.&lt;/p&gt;
&lt;p&gt;On &lt;strong&gt;reasoning&lt;/strong&gt;, Google cites 91.9% on GPQA Diamond, a test of graduate-level science questions, and 37.5% on &quot;Humanity&apos;s Last Exam,&quot; a hard exam spanning many subjects.&lt;/p&gt;
&lt;p&gt;On &lt;strong&gt;coding&lt;/strong&gt;, the numbers are about concrete tasks. On SWE-bench Verified, which measures the ability to fix real bugs pulled from GitHub projects, the model claims 76.2%. On Terminal-Bench 2.0, which rates completing tasks inside a terminal, 54.2%.&lt;/p&gt;
&lt;p&gt;Then there are the human-vote leaderboards, where people compare answers from different models without knowing which is which. Google reports topping LMArena (1501 Elo points) and WebDev Arena (1487), the latter focused on building small web apps. These are useful signals to get a sense of things, not definitive proof.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Wondering whether Gemini 3 is worth integrating into your systems?&quot; text=&quot;We weigh benchmarks, costs, and risks against the real use case before choosing a model.&quot; button=&quot;Ask for an assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;Why it matters for agents and automation&lt;/h2&gt;
&lt;p&gt;An &lt;strong&gt;agent&lt;/strong&gt; is a program that, beyond answering, takes concrete actions on your behalf: it reads files, runs commands, uses external tools often connected through open standards like &lt;a href=&quot;/en/changelog/what-is-mcp&quot;&gt;MCP&lt;/a&gt;. Anyone evaluating a model to build automation looks at exactly this, not just the quality of the text it produces.&lt;/p&gt;
&lt;p&gt;That&apos;s why benchmarks like Terminal-Bench or SWE-bench weigh more than others: they show how the model does when it has to move among files, commands, and tools, rather than just chatting. Along with the model, Google introduced &lt;strong&gt;Antigravity&lt;/strong&gt;, a development platform built to let agents work with direct access to the editor, the terminal, and the browser. Gemini 3 also lands inside &lt;a href=&quot;/en/changelog/gemini-cli&quot;&gt;Gemini CLI&lt;/a&gt;, the existing command-line assistant.&lt;/p&gt;
&lt;p&gt;For people designing systems, one more technical detail matters: the API introduces a &lt;strong&gt;thinking level&lt;/strong&gt; parameter, which sets how deeply the model should &quot;reason&quot; before answering. It&apos;s a practical lever: reasoning more can improve quality on complex problems, but it costs more and takes longer. Being able to tune it helps balance spend, speed, and accuracy for each task.&lt;/p&gt;
&lt;h2&gt;How to try it and what it costs&lt;/h2&gt;
&lt;p&gt;For developers, Gemini 3 Pro is reachable through the Gemini API in two places: &lt;strong&gt;Google AI Studio&lt;/strong&gt;, with free access subject to usage limits, and &lt;strong&gt;Vertex AI&lt;/strong&gt;, the cloud platform aimed at businesses. The model is also built into third-party tools already popular among developers, such as Cursor, GitHub, JetBrains, and Replit. For the general public, it arrived in the Gemini app and in some Search features.&lt;/p&gt;
&lt;p&gt;On costs, Google listed a price of $2 per million input tokens and $12 per million output tokens, for requests up to 200,000 tokens; past that threshold the rate changes. These figures help estimate the cost of heavy use, but should be checked against the documentation at the time of adoption, since model pricing changes often.&lt;/p&gt;
&lt;h2&gt;The caveats&lt;/h2&gt;
&lt;p&gt;Before moving over to the new model, a few points are worth keeping in mind, without hype.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;It&apos;s a preview.&lt;/strong&gt; Google describes it as a preview release: behavior, features, and prices can change. It&apos;s not the thing to hang critical processes on without a ready fallback.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;The numbers are one-sided.&lt;/strong&gt; The benchmarks are stated by the party selling the product and measure standardized scenarios. The only reliable judge is trying it on your own real use cases.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Data goes to the cloud.&lt;/strong&gt; As with the earlier models, the computation runs on Google&apos;s servers: whatever you send the model leaves your own computer. For confidential content, that&apos;s something to weigh carefully, also in light of what &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR requires on the infrastructure side&lt;/a&gt; when personal data is involved.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Not everything is available at once.&lt;/strong&gt; Deep Think and some features weren&apos;t accessible to everyone at launch. It&apos;s best to check what you can actually use, and on which plan, before relying on a specific capability.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Gemini 3 is the new generation of Google&apos;s models, with Gemini 3 Pro available in preview and a Deep Think mode announced for the hardest reasoning tasks. Google claims improvements in reasoning, coding, and multimodal understanding, with interesting but one-sided numbers. For those building agents and automations, the most concrete news is the better performance on practical tasks, the Antigravity platform, and the control over reasoning depth through the API. It remains a preview tool, running in the cloud, to be measured on your own cases: worth trying, without taking the press releases at face value.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to bring AI into your workflows with judgment?&quot; text=&quot;We design automations and agents that use models like Gemini 3 inside the software we build, with attention to data security and per-request costs.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.google/products/gemini/gemini-3/&quot;&gt;Gemini 3: Introducing the latest Gemini AI model from Google - The Keyword, Google&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.google/technology/developers/gemini-3-developers/&quot;&gt;Gemini 3 for developers - The Keyword, Google&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>How to Choose a Cloud Provider: The Criteria That Actually Matter</title><link>https://initd.it/en/changelog/cloud-provider-comparison</link><guid isPermaLink="true">https://initd.it/en/changelog/cloud-provider-comparison</guid><description>A neutral guide to the criteria that matter when choosing a cloud provider: pricing model, hidden costs like data egress, managed versus self-managed services, where your data lives and GDPR, lock-in, and support.</description><pubDate>Thu, 13 Nov 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Choosing where to host a website, an application, or an entire company system is one of those decisions that look purely technical but weigh on the budget for years. The cloud market offers dozens of providers, each with its own price list, and the risk is comparing them by looking at the wrong line item. This guide lays out the criteria that actually matter, without pushing any particular provider: the goal is to help you reason, not to sell.&lt;/p&gt;
&lt;p&gt;By &quot;cloud provider&quot; we mean a company that rents out computing resources over the Internet: processing power, storage, networking. Instead of buying a server and keeping it in the office, you pay a fee to use one (or a thousand) remotely. So far, so simple. The complexity shows up when you try to work out what it really costs.&lt;/p&gt;
&lt;h2&gt;The pricing model: hyperscaler versus VPS&lt;/h2&gt;
&lt;p&gt;Simplifying a lot, providers fall into two big families. On one side, the hyperscalers - the global giants like Amazon Web Services (AWS), Microsoft Azure, and Google Cloud - which sell a catalog of hundreds of separate services, from traditional compute instances to the &lt;a href=&quot;/en/changelog/aws-graviton5&quot;&gt;new ARM chips built to cut costs&lt;/a&gt;. On the other, the VPS providers (Virtual Private Server, a virtual machine on a flat fee) with an almost all-inclusive price.&lt;/p&gt;
&lt;p&gt;The difference isn&apos;t just scale, it&apos;s philosophy. A hyperscaler doesn&apos;t sell you &quot;a machine&quot;: it sells you the compute instance, and then - as separate line items - the public IP address, disk storage, backups, the load balancer, network traffic, and the support plan. The instance price is the tip of the iceberg. A VPS starts from the opposite idea: one fee that already includes disk, traffic, and an IP address. Less flexible, but far easier to budget for.&lt;/p&gt;
&lt;p&gt;Neither model is &quot;right&quot; in absolute terms. The point is that comparing them only on the hourly instance price is misleading, because that price covers different things in each case.&lt;/p&gt;
&lt;h2&gt;The hidden cost: data egress&lt;/h2&gt;
&lt;p&gt;If there&apos;s one line item that blows up estimates, it&apos;s outbound bandwidth, or &lt;em&gt;egress&lt;/em&gt;: the data traffic that leaves the cloud toward the Internet, that is, toward your users. Every image, video, download, or API response that reaches a visitor is outbound traffic.&lt;/p&gt;
&lt;p&gt;On hyperscalers this traffic is metered, charged per gigabyte. AWS, for example, includes 100 GB per month for free, aggregated across all services, and then bills every gigabyte after that. It sounds like little, but a website with lots of images or a service that distributes files can move terabytes a month: at that point bandwidth becomes one of the heaviest items on the bill, sometimes more than the instance itself.&lt;/p&gt;
&lt;p&gt;VPS providers usually flip the logic: they bundle a very generous traffic allowance into the fee and charge very little for any overage. The practical consequence is simple: if your application moves a lot of data outward, the metered model can cost orders of magnitude more. If instead it mostly burns CPU and database with little traffic, the gap narrows. The rule is to estimate outbound bandwidth before you choose, not after the first bill.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do you actually know what outbound bandwidth would cost for your workload?&quot; text=&quot;We analyse your application&apos;s real traffic and compare hyperscalers and VPS on actual cost, not on the instance price tag.&quot; button=&quot;Get an estimate →&quot;}&lt;/p&gt;
&lt;h2&gt;Managed or self-managed?&lt;/h2&gt;
&lt;p&gt;Here the comparison flips. A &lt;em&gt;managed&lt;/em&gt; service is a resource the provider maintains on your behalf: a managed database, for instance, is updated, backed up, and replicated automatically, with the node replaced if it fails. The alternative is &lt;em&gt;self-managed&lt;/em&gt;: the provider hands you a bare machine, and the database, updates, backups, and monitoring are yours to configure and keep running.&lt;/p&gt;
&lt;p&gt;Hyperscalers excel at managed services, from the fully administered database to &lt;a href=&quot;/en/changelog/cloud-run-gpu&quot;&gt;serverless GPUs for AI inference&lt;/a&gt;: they have enormous catalogs that take operational work off your plate. VPS providers mostly offer raw material - excellent and cheap, but yours to administer. The right question isn&apos;t &quot;who has more of them,&quot; but &quot;how much is my time worth.&quot; A managed database costs more than one you install by hand, but that premium is the work (and the 3 a.m. on-call) you don&apos;t have to do yourself. If the skills to run infrastructure exist in-house, self-managed saves money; if they don&apos;t, the managed service often costs less than the staff you&apos;d otherwise need. Self-managed isn&apos;t free: it&apos;s a cost that shifts from the cloud bill to the hours of whoever runs it.&lt;/p&gt;
&lt;h2&gt;Where the data lives: data centers, the EU, and GDPR&lt;/h2&gt;
&lt;p&gt;A provider has data centers - the warehouses full of servers - in geographic zones called &lt;em&gt;regions&lt;/em&gt;. The choice of region matters for two reasons. The first is latency: the closer the server is to your users, the faster the responses arrive. The second, often more important, is legal.&lt;/p&gt;
&lt;p&gt;The &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR&lt;/a&gt;, the European data protection regulation, sets precise rules on where personal data can end up. Its Chapter V (Articles 44 and following) establishes that transferring personal data outside the European Union is prohibited unless specific conditions are met. In plain terms: if you handle data belonging to European citizens, the physical location of that data is not a detail.&lt;/p&gt;
&lt;p&gt;There&apos;s a subtlety that many people miss, though. Choosing a European region isn&apos;t enough to shield the data from every outside request. Because of the U.S. CLOUD Act, American jurisdiction follows the company, not the server: a provider subject to U.S. law can be compelled to hand over the data it controls even if it&apos;s stored in a European data center. This doesn&apos;t mean American hyperscalers are &quot;outlaws&quot; - they&apos;ve built dedicated offerings to address the issue - but that data sovereignty has to be judged on the specific product and the legal entity that runs it, not on the flag in the logo.&lt;/p&gt;
&lt;h2&gt;The risk of lock-in&lt;/h2&gt;
&lt;p&gt;&lt;em&gt;Lock-in&lt;/em&gt; means technical dependence: how costly and complicated it is to switch providers once you&apos;re in. On a VPS it&apos;s low, because it&apos;s usually a standard Linux machine you can migrate elsewhere in an afternoon. On a hyperscaler it can be high, because proprietary services - bespoke databases, &lt;em&gt;serverless&lt;/em&gt; functions, message queues - don&apos;t exist in the same form elsewhere, and rewriting them costs.&lt;/p&gt;
&lt;p&gt;There&apos;s also a subtler form of lock-in: data gravity. The more data you accumulate in a service, the more it costs to take it out, because moving those terabytes goes through that same billable outbound bandwidth. The cost of egress thus doubles as a toll that discourages migration. The defense is architectural: prefer standard, open components where you can, describe your infrastructure with &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;Infrastructure as Code&lt;/a&gt; tools instead of by hand, and know from the start what a move would cost. Lock-in isn&apos;t a moral flaw, it&apos;s a choice to make with your eyes open.&lt;/p&gt;
&lt;h2&gt;Support&lt;/h2&gt;
&lt;p&gt;The last criterion, often underrated: what happens when something breaks at 3 a.m. Support levels vary enormously. Some providers include basic assistance in the fee; hyperscalers sell support plans separately, often as a percentage of monthly spend. It&apos;s worth reading the SLA (&lt;em&gt;Service Level Agreement&lt;/em&gt;): it promises a certain uptime and certain response times, but often the &quot;refund&quot; for an outage is just a credit on the bill, not compensation for the real damage. Support isn&apos;t judged by the phone number on the homepage, but by what&apos;s written in the contract.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;There&apos;s no &quot;best cloud&quot;: there&apos;s the right model for a specific workload. It pays to go in order. First, estimate outbound bandwidth, the variable that most often overturns the math. Then decide how much operational work to delegate, choosing between managed and self-managed based on the skills available. Next, check where the data has to live and who can be compelled to hand it over. Finally, factor in the risk of lock-in and actually read the support terms. The hourly instance price, the one everyone compares first, is almost always the least important item.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Choosing or switching cloud providers for your infrastructure?&quot; text=&quot;We design and run custom infrastructure on AWS, Google Cloud, and VPS, weighing cost, GDPR, and lock-in risk together before you sign anything.&quot; button=&quot;Let&apos;s talk about your infrastructure →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://aws.amazon.com/ec2/pricing/on-demand/&quot;&gt;Amazon EC2 On-Demand Pricing&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.hetzner.com/cloud&quot;&gt;Hetzner Cloud&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://gdpr-info.eu/chapter-5/&quot;&gt;GDPR - Chapter V: Transfers to third countries (Art. 44 ff.)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://iapp.org/news/a/questions-to-ask-for-compliance-with-the-eu-gdpr-and-the-u-s-cloud-act&quot;&gt;Questions to ask for compliance with the EU GDPR and the U.S. CLOUD Act - IAPP&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Native page animations in the browser: View Transitions go Baseline</title><link>https://initd.it/en/changelog/view-transitions-baseline</link><guid isPermaLink="true">https://initd.it/en/changelog/view-transitions-baseline</guid><description>Same-document View Transitions are now supported across all major browsers. What they are, the problem they solve, and why they simplify animating between page states without JavaScript libraries.</description><pubDate>Tue, 21 Oct 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Changing the view on a website is almost always an abrupt jump: one piece of content disappears, another shows up, with no smooth handoff in between. To get the kind of fluid animations you see in apps - an image growing into place, a list sliding in tidily - you usually need dedicated JavaScript libraries, with code to write and maintain. In mid-October 2025 something changed for people who build websites: same-document View Transitions, meaning animated transitions within the same page, became Baseline. In plain terms, they now work reliably across all the major browsers, and most of the work is done by the browser itself.&lt;/p&gt;
&lt;h2&gt;The news in brief&lt;/h2&gt;
&lt;p&gt;On 14 October 2025, same-document View Transitions reached &quot;Baseline Newly available&quot; status. The shift happened when Firefox 144 shipped, the last of the three main browser engines to support the feature. Google Chrome has offered it since 2023 (from version 111), and Apple&apos;s Safari since version 18, released in September 2024. With Firefox on board, the circle closes: the same feature, written once, behaves the same everywhere. This milestone is part of Interop 2025, the initiative through which browser makers agree on a list of web features to make work consistently across engines over the course of the year.&lt;/p&gt;
&lt;h2&gt;What &quot;Baseline&quot; means&lt;/h2&gt;
&lt;p&gt;Baseline is a label built to answer a practical question: can I use this feature without worrying that I&apos;ll leave out a slice of my visitors? A feature is Baseline when it&apos;s supported by the recent versions of browsers built on the three most common engines: Chromium (Chrome, Edge, and others), WebKit (Safari), and Gecko (Firefox).&lt;/p&gt;
&lt;p&gt;The &quot;Newly available&quot; status means the milestone has only just been reached: the feature is ready to use, but older devices may still run browser versions without support. Over time, as updates spread, the status moves to &quot;Widely available.&quot; Knowing that a feature is Baseline helps you decide, with some confidence, whether to adopt it in a real project.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your site jump between views instead of transitioning smoothly?&quot; text=&quot;We can check whether you can already use native View Transitions without adding any library.&quot; button=&quot;Check your site →&quot;}&lt;/p&gt;
&lt;h2&gt;What a view transition is&lt;/h2&gt;
&lt;p&gt;A view transition is an animation that connects two states of a page. Picture a photo gallery: you tap a thumbnail and watch it grow into the full-size image, instead of it popping in all at once. Until recently, an effect like that had to be built by hand.&lt;/p&gt;
&lt;p&gt;From the browser&apos;s point of view, the mechanism is easy to describe. When a transition starts, the browser takes a &quot;photograph&quot; of the page as it is now, lets the content change, takes a second photograph of the new state, and animates the move from the first to the second. The default effect is a cross-fade: the old look fades out as the new one appears. With a few lines of CSS you can then get more elaborate motion, such as a slide or a zoom.&lt;/p&gt;
&lt;p&gt;October&apos;s news concerns same-document transitions, the ones that happen without leaving the page, while the content is updated via JavaScript. This is the typical scenario for single-page applications, where the site rewrites parts of the screen without reloading everything. There&apos;s also a cross-document variant, meant for transitions between different pages during ordinary navigation: it&apos;s a related but separate feature, on its own track, and it isn&apos;t the subject of this announcement.&lt;/p&gt;
&lt;h2&gt;The problem it solves&lt;/h2&gt;
&lt;p&gt;Until now, animating the move between two states nicely almost always called for specialized JavaScript libraries, much like positioning tooltips and menus used to before &lt;a href=&quot;/en/changelog/css-anchor-positioning&quot;&gt;CSS Anchor Positioning&lt;/a&gt;. These are capable tools, but they come at a cost: extra code to load and maintain, animations to sync by hand, and the risk of weighing the page down. There&apos;s a consistency angle too, since every library does things its own way.&lt;/p&gt;
&lt;p&gt;By moving this work into the browser, much of that code is no longer needed. The browser knows the position and appearance of elements before and after the change, so it can work out the animation efficiently. For many common cases you get a pleasant transition without adding any library at all, with an indirect benefit for how responsive the page feels to interactions too, the same thing &lt;a href=&quot;/en/changelog/inp-core-web-vital&quot;&gt;INP&lt;/a&gt; measures.&lt;/p&gt;
&lt;h2&gt;How it works, in practice&lt;/h2&gt;
&lt;p&gt;The heart of the feature is a single method, &lt;code&gt;document.startViewTransition()&lt;/code&gt;. You hand it the function that changes the page content, and the browser takes care of the animation.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// Update with no animation
function updatePage() {
  // ... this is where the page content changes ...
}

// With an animated transition, when the browser supports it
function updateWithTransition() {
  if (!document.startViewTransition) {
    updatePage(); // fallback: just update
    return;
  }
  document.startViewTransition(() =&amp;gt; updatePage());
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The key part is the &lt;code&gt;if (!document.startViewTransition)&lt;/code&gt; check: if the browser doesn&apos;t know the feature, the content still updates, just without the animation. This approach, called progressive enhancement, keeps the site fully working everywhere, with the animation as a bonus where it&apos;s available.&lt;/p&gt;
&lt;p&gt;To animate a single element independently from the rest - for example to make an image &quot;travel&quot; from the thumbnail to its large version - you give it a name through the CSS property &lt;code&gt;view-transition-name&lt;/code&gt;. The browser recognizes that the element is the same before and after the change, and animates it accordingly, rather than settling for the general cross-fade.&lt;/p&gt;
&lt;h2&gt;What changes for frontend developers, and a couple of caveats&lt;/h2&gt;
&lt;p&gt;For anyone building interfaces, the main upside is less code to write for a smoother result. Two details are still worth keeping in mind.&lt;/p&gt;
&lt;p&gt;The first concerns Firefox: its first version with this feature doesn&apos;t yet include so-called view transition types, a more advanced tool for applying different animations depending on context. If you need them, you can plan a fallback, exactly like the check shown above.&lt;/p&gt;
&lt;p&gt;The second is accessibility. Not everyone welcomes animation, and some people find it distracting or uncomfortable. Operating systems offer a setting to reduce motion, which on the web is read through the CSS &lt;code&gt;prefers-reduced-motion&lt;/code&gt; rule. It&apos;s good practice to respect it, dialing the animation down or off for anyone who asked for less movement.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Same-document View Transitions became Baseline on 14 October 2025, when support landed in Firefox 144 alongside Chrome and Safari. In practice, the browser can now animate the move between two states of a page on its own, a job that used to call for JavaScript libraries almost every time, much like other capabilities now shipping natively in the browser, such as &lt;a href=&quot;/en/changelog/browser-ai-prompt-api&quot;&gt;AI running right there inside it&lt;/a&gt;. For people building sites it means less code, more consistent animations, and potentially lighter pages, as long as you handle older browsers and reduced-motion preferences with care. It&apos;s one of those quiet changes that, over time, make the web a little more pleasant to use.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want smoother animations without bloating the frontend?&quot; text=&quot;We build View Transitions and other native browser features into the sites and Vue applications we develop, keeping the code lean.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/blog/same-document-view-transitions-are-now-baseline-newly-available&quot;&gt;Same-document view transitions have become Baseline Newly available - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.chrome.com/blog/view-transitions-in-2025&quot;&gt;What&apos;s new in view transitions (2025 update) - Chrome for Developers&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.mozilla.org/en-US/docs/Web/API/View_Transition_API&quot;&gt;View Transition API - MDN&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Agent Skills: packaging know-how for AI assistants</title><link>https://initd.it/en/changelog/agent-skills</link><guid isPermaLink="true">https://initd.it/en/changelog/agent-skills</guid><description>Anthropic introduced Agent Skills: folders with a SKILL.md file that bundle reusable instructions and scripts for agents. What they are, the problem they solve, and why they matter, explained simply.</description><pubDate>Thu, 16 Oct 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;AI assistants are good at answering questions and writing text. But when they have to follow a precise procedure - the way a given company prepares a report, applies a file-naming convention, or fills in a form - they need to be guided every time. Usually you end up re-pasting the same instructions into every conversation, or building a custom assistant for each task. On 16 October 2025 Anthropic, the company behind the Claude assistant, introduced &lt;strong&gt;Agent Skills&lt;/strong&gt;: a way to package those instructions, and any scripts, into reusable folders that the assistant loads only when they&apos;re needed.&lt;/p&gt;
&lt;p&gt;Behind the technical name there&apos;s a simple idea, and it matters to anyone who uses AI for recurring work. It&apos;s worth understanding.&lt;/p&gt;
&lt;h2&gt;First, a note on terms&lt;/h2&gt;
&lt;p&gt;Here &lt;strong&gt;agent&lt;/strong&gt; means an AI assistant that doesn&apos;t just reply, but can &lt;a href=&quot;/en/changelog/what-is-mcp&quot;&gt;use tools&lt;/a&gt; and take several steps to complete a task: read a file, run a small program, produce a document. Another useful term is &lt;strong&gt;context&lt;/strong&gt;: everything the assistant &quot;has in front of it&quot; while working, meaning the user&apos;s request plus the instructions and information loaded at that moment. Context has limited room - the more you cram in, the more scattered and expensive it gets. Keeping that limit in mind helps explain why Skills are built the way they are.&lt;/p&gt;
&lt;h2&gt;The problem: every procedure rewritten from scratch&lt;/h2&gt;
&lt;p&gt;Over time an organization builds up a store of &quot;how we do things here&quot;: the standard format for an invoice, the steps to produce a monthly report, the style rules for a piece of writing, the exact sequence to package a piece of software. This is procedural knowledge, often not written down anywhere in an orderly way.&lt;/p&gt;
&lt;p&gt;To get an AI assistant to follow one of these procedures there are two options, both awkward. The first is pasting the instructions into the conversation every time: it works, but it&apos;s repetitive and easy to get wrong, and it eats up precious room in the context. The second is building a dedicated assistant for each single task: precise, but it takes technical work and has to be redone for each of the many procedures. Either way, the know-how stays hard to reuse and hard to share.&lt;/p&gt;
&lt;p&gt;Agent Skills exist to remove exactly this friction: write a procedure once, in an orderly format, then call it up when needed without pasting it again.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your team&apos;s know-how still live only in someone&apos;s head?&quot; text=&quot;We help you work out which recurring processes are worth turning into automations or reusable Skills, weighing security and cost.&quot; button=&quot;Ask for an assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;What a Skill is: a folder with instructions inside&lt;/h2&gt;
&lt;p&gt;In practice a Skill is simply a &lt;strong&gt;folder&lt;/strong&gt;. Inside there&apos;s one required file called &lt;code&gt;SKILL.md&lt;/code&gt; and, if needed, other files: reference documents, examples, or small ready-made scripts.&lt;/p&gt;
&lt;p&gt;The &lt;code&gt;SKILL.md&lt;/code&gt; file is written in a format a person can read too. At the top it has a few lines of metadata in YAML - a plain way to note &quot;label: value&quot; pairs - with at least a &lt;strong&gt;name&lt;/strong&gt; and a &lt;strong&gt;description&lt;/strong&gt; of what the Skill does. Below that, in Markdown (the same plain text used in many note files), come the actual instructions: the steps to follow, the conventions to respect, the examples. In short, it&apos;s a tidy instruction sheet. Anthropic uses a neat analogy: building a Skill is like putting together an onboarding guide for a new hire.&lt;/p&gt;
&lt;p&gt;A minimal structure looks like this:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;monthly-report/
  SKILL.md        # what it does and how, step by step
  example.md      # a worked case, for reference
  generate.py     # an optional script for the repetitive steps
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The fact that it&apos;s a folder of text files has a real practical upside: a Skill can be saved, version-controlled the way code is, and handed to a colleague by simply sharing the folder.&lt;/p&gt;
&lt;h2&gt;The trick: loading information in layers&lt;/h2&gt;
&lt;p&gt;If every Skill were loaded in full and always, you&apos;d be back to the problem of a cluttered context. Agent Skills avoid this with &lt;strong&gt;progressive&lt;/strong&gt; loading - in layers - so the assistant only has in front of it what it needs at that moment.&lt;/p&gt;
&lt;p&gt;It works in three levels:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;At startup the assistant only knows the &lt;strong&gt;name and description&lt;/strong&gt; of each available Skill. A few lines each: just enough to know that the Skill exists and what it&apos;s for.&lt;/li&gt;
&lt;li&gt;When the user&apos;s request matches a Skill, the assistant opens and reads the &lt;strong&gt;full contents&lt;/strong&gt; of that &lt;code&gt;SKILL.md&lt;/code&gt;, with all the instructions.&lt;/li&gt;
&lt;li&gt;If the &lt;code&gt;SKILL.md&lt;/code&gt; points to other files - a detailed document, a long example - those are opened &lt;strong&gt;only when actually needed&lt;/strong&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The result is that you can keep many Skills on hand, even sizeable ones, without weighing down every conversation. The assistant &quot;scans the index&quot; and reads the right chapter only when it needs to, instead of keeping every manual open on the desk.&lt;/p&gt;
&lt;p&gt;There&apos;s a second useful element: a Skill can include &lt;strong&gt;ready-written scripts&lt;/strong&gt;, for example in Python. For repetitive, mechanical steps, the assistant can run that code instead of improvising the procedure every time, much like relying on an &lt;a href=&quot;/en/changelog/systemd-timers&quot;&gt;automated timer&lt;/a&gt; for a task that would otherwise have to be kicked off by hand. For certain tasks it&apos;s more reliable and cheaper to run a tested script than to ask the model to redo everything by hand.&lt;/p&gt;
&lt;h2&gt;Where they can be used&lt;/h2&gt;
&lt;p&gt;Agent Skills work in the same format across several places: the Claude app (on the Pro, Max, Team and Enterprise plans), the developer tool Claude Code, the developer-facing API, and the Agent SDK, the kit for building your own agents. The same package, then, moves from one environment to another without being rewritten.&lt;/p&gt;
&lt;p&gt;At launch Anthropic made available a few ready-made Skills for very common office tasks: creating Excel spreadsheets with formulas, PowerPoint presentations, Word documents, and fillable PDF forms. There&apos;s also a special Skill, the &lt;strong&gt;skill-creator&lt;/strong&gt;, that helps build new ones in a guided way: it asks about your workflow, prepares the folder structure, and sets up the &lt;code&gt;SKILL.md&lt;/code&gt; file. A way to start without facing a blank page.&lt;/p&gt;
&lt;p&gt;On availability, to be fair, not everything is identical everywhere: use via the API, for instance, relies on the code-execution feature, still in beta, and in enterprise accounts an administrator has to enable the feature for the organization. Small details, but useful ones so you&apos;re not caught off guard.&lt;/p&gt;
&lt;h2&gt;Why it helps anyone with recurring procedures&lt;/h2&gt;
&lt;p&gt;The real value isn&apos;t in a single feature, but in the shift in work it makes possible. A procedure written well once stops being an instruction to repeat out loud and becomes a reusable piece: you call it up when needed, you can improve it over time by editing a file, you hand it to a colleague by sharing a folder. In practice it&apos;s a way to &lt;strong&gt;capitalize&lt;/strong&gt; on the know-how that today lives in people&apos;s heads or scattered across different notes.&lt;/p&gt;
&lt;p&gt;For anyone running systems and infrastructure the comparison is immediate: it&apos;s the same logic by which a repetitive procedure is better put in a script or a &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;playbook&lt;/a&gt; than run from memory every time. Here the &quot;playbook&quot; is written so an AI assistant can follow it, with the option to include the code for the mechanical steps too.&lt;/p&gt;
&lt;h2&gt;Mind where they come from&lt;/h2&gt;
&lt;p&gt;A word of caution, one Anthropic itself highlights. A Skill can contain instructions and code that get executed, and it can tell the assistant to access external resources. So they should only be installed from sources you trust, and ones of uncertain origin are worth inspecting first: what the files contain, whether the code connects to external services, whether there are instructions that might send data somewhere it shouldn&apos;t go. It&apos;s the same caution you&apos;d use before running &lt;a href=&quot;/en/changelog/npm-supply-chain-cooldown&quot;&gt;a script downloaded from the internet&lt;/a&gt;. Convenience doesn&apos;t remove the responsibility to check.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Agent Skills, introduced by Anthropic on 16 October 2025, are folders that gather reusable instructions and scripts for AI assistants, built around a plain-text &lt;code&gt;SKILL.md&lt;/code&gt; file. They solve a concrete, everyday problem: not having to rewrite the same procedures every time. Layered loading lets you keep many of them on hand without cluttering the context, and the option to include scripts makes repetitive steps more reliable. They work in the app, in Claude Code, via the API, and with the Agent SDK. How widely used they&apos;ll become is for the coming months to tell; the underlying idea, though, is clear and sensible: put know-how in an orderly, reusable format, instead of repeating it out loud every time.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to bring AI into your company&apos;s workflows?&quot; text=&quot;We design custom AI integrations for your Laravel and Vue applications, checking data security and cost before anything goes live.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills&quot;&gt;Equipping agents for the real world with Agent Skills - Anthropic&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://claude.com/blog/skills&quot;&gt;Agent Skills - Claude (Anthropic)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Over Half of Web Traffic Is Now Post-Quantum: What That Means</title><link>https://initd.it/en/changelog/post-quantum-adoption</link><guid isPermaLink="true">https://initd.it/en/changelog/post-quantum-adoption</guid><description>By late October 2025, more than half of human web traffic to Cloudflare uses post-quantum cryptography. What it means, the threat it guards against, and what&apos;s still missing.</description><pubDate>Tue, 14 Oct 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;In late October 2025 Cloudflare, one of the large networks that carry a big share of Internet traffic, announced a milestone: more than half of the human-initiated web traffic passing through its servers is now protected with &lt;strong&gt;post-quantum&lt;/strong&gt; cryptography. The term sounds like something from a lab, but the issue touches anyone who uses a website, shops online, or sends a message. It&apos;s worth understanding what it means, which threat it guards against, and what&apos;s still left to do.&lt;/p&gt;
&lt;h2&gt;The news in brief&lt;/h2&gt;
&lt;p&gt;The announcement marks a quiet turning point. A few years ago post-quantum cryptography was confined to experiments; today it&apos;s on by default in most of the widely used browsers. &lt;a href=&quot;/en/changelog/chrome-post-quantum-tls&quot;&gt;Chrome enabled it on desktop&lt;/a&gt; in March 2024 and on Android in November 2024; during 2025, Firefox and Apple&apos;s systems on iPhone, iPad, and Mac joined in. The result is that, without users doing anything, more than one connection in two now starts out protected against an attack that isn&apos;t possible today but could become so later.&lt;/p&gt;
&lt;h2&gt;The problem: &quot;harvest now, decrypt later&quot;&lt;/h2&gt;
&lt;p&gt;To see why this matters, start with a threat that has an unsettling name: &lt;strong&gt;harvest now, decrypt later&lt;/strong&gt;. The idea is simple and uncomfortable. Internet traffic today is encrypted: when the padlock shows up in your browser, the data traveling between your device and the site is made unreadable to anyone intercepting it. That protection holds because today&apos;s computers don&apos;t have the raw power to break it in any reasonable time.&lt;/p&gt;
&lt;p&gt;The catch is that &lt;strong&gt;quantum computers&lt;/strong&gt; - a technology still under development, built on different principles from ordinary computers - could one day break much of the cryptography we rely on now. That hypothetical moment is called &quot;Q-day.&quot; Nobody knows for sure whether or when it will arrive: expert estimates range from a bit more than ten years to several decades. But one detail makes the problem present rather than future: someone intercepting encrypted traffic today can store it and archive it, waiting to decrypt it once the technology allows. Data that stays sensitive for years - medical records, trade secrets, confidential communications - is therefore already at risk now, even though the machine capable of opening it doesn&apos;t exist yet.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do you know if your servers already support post-quantum key exchange?&quot; text=&quot;We check your servers&apos; TLS configuration and its compatibility with post-quantum algorithms.&quot; button=&quot;Get a review →&quot;}&lt;/p&gt;
&lt;h2&gt;The answer: post-quantum cryptography&lt;/h2&gt;
&lt;p&gt;The countermeasure is called &lt;strong&gt;post-quantum cryptography&lt;/strong&gt;: new algorithms designed to resist even a quantum computer. They don&apos;t need special hardware, they&apos;re ordinary software, and they run on everyday devices. The part that arrived first is &lt;strong&gt;key exchange&lt;/strong&gt; (also called key agreement): the opening step of a secure connection, where the browser and the site agree on a shared secret key that is then used to encrypt the rest of the conversation. That step is exactly what&apos;s exposed to the &quot;harvest now, decrypt later&quot; attack, so it&apos;s the first thing to secure.&lt;/p&gt;
&lt;h2&gt;Hybrid key exchange&lt;/h2&gt;
&lt;p&gt;In practice, the old cryptography wasn&apos;t thrown out and replaced with the new one. The approach is &lt;strong&gt;hybrid&lt;/strong&gt;: a classical algorithm, proven over years, is combined with a post-quantum one. The connection stays protected as long as at least one of the two holds. So if a weakness were later found in the new algorithm - not impossible, given how recent it is - the traditional one would still provide protection; and against a quantum attack, the new part does the job. Belt and suspenders, together.&lt;/p&gt;
&lt;p&gt;The most common scheme right now is called &lt;strong&gt;X25519MLKEM768&lt;/strong&gt;. The name is a mouthful, but it says exactly what&apos;s inside: &lt;em&gt;X25519&lt;/em&gt; is the classical algorithm long used for key exchange, and &lt;em&gt;ML-KEM-768&lt;/em&gt; is the post-quantum part. ML-KEM (short for &lt;em&gt;Module-Lattice-Based Key-Encapsulation Mechanism&lt;/em&gt;, previously known as Kyber) was officially standardized by the US agency NIST on 13 August 2024, under the name &lt;strong&gt;FIPS 203&lt;/strong&gt;. So it isn&apos;t one vendor&apos;s experiment, but a public standard the industry is aligning around. All of this runs inside &lt;strong&gt;&lt;a href=&quot;/en/changelog/tls-encrypted-client-hello&quot;&gt;TLS 1.3&lt;/a&gt;&lt;/strong&gt;, the protocol behind &lt;code&gt;https&lt;/code&gt; and the browser padlock.&lt;/p&gt;
&lt;h2&gt;Why &quot;over 50%&quot; is a real milestone&lt;/h2&gt;
&lt;p&gt;That such a large share of traffic already uses these algorithms isn&apos;t a detail for insiders. Passing the halfway mark means the protection is no longer an exception but is becoming the norm, transparently for the person browsing. The credit goes mostly to browsers, which turned it on by default: users didn&apos;t have to install or configure anything. On the site side, adoption lags further behind - scans from September 2025 put roughly 39% of public web servers ready to use it - but the direction is clear. It&apos;s also worth remembering that Cloudflare&apos;s figure covers &quot;human-initiated&quot; traffic, meaning connections from real browsers, kept separate from automated bot traffic.&lt;/p&gt;
&lt;h2&gt;What&apos;s still missing: signatures and certificates&lt;/h2&gt;
&lt;p&gt;The picture, though, is only half complete. Cryptography does two different jobs, and both need to become post-quantum. The first is keeping data secret: that&apos;s the key exchange just described, and it&apos;s the part already in production. The second is &lt;strong&gt;authentication&lt;/strong&gt;: making sure you&apos;re really talking to the right site and not an impostor. That relies on &lt;strong&gt;certificates&lt;/strong&gt; and &lt;strong&gt;digital signatures&lt;/strong&gt;, and it&apos;s the part still behind.&lt;/p&gt;
&lt;p&gt;The reason is technical but understandable: post-quantum signatures take up much more space than current ones, which creates performance and compatibility problems with systems built for smaller sizes. At the time of the announcement, in October 2025, the standards for post-quantum certificates were not yet final; work on &quot;hybrid&quot; certificates was underway, with hopes of wrapping it up in early 2026. Certificates like these are unlikely to be in widespread use before 2027. Meanwhile, other NIST standards for signatures are already published - ML-DSA (FIPS 204) and SLH-DSA (FIPS 205), both released in 2024 - along with a backup key-exchange algorithm, &lt;a href=&quot;/en/changelog/nist-hqc-post-quantum&quot;&gt;HQC&lt;/a&gt;, chosen in March 2025 as an alternative built on different mathematical principles.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;For most people there&apos;s nothing to do: keep browsers and operating systems updated, and the protection arrives on its own. For those who run sites and servers, the message is to prepare without rushing but without putting it off: check that your stack supports post-quantum key exchange, keep software current, and, looking further ahead, get used to the idea that &lt;a href=&quot;/en/changelog/tls-certificates-47-days&quot;&gt;certificates will need to be reissued in new formats&lt;/a&gt;. Several authorities - in the US, Europe, the UK, and Australia - point to migration deadlines between 2030 and 2035: there&apos;s time, but that&apos;s no reason to wait passively.&lt;/p&gt;
&lt;p&gt;Passing the 50% mark doesn&apos;t solve the problem, but it signals that the transition has genuinely started and is moving along quietly, one browser update at a time.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to bring your infrastructure up to date with post-quantum cryptography?&quot; text=&quot;We update and manage TLS configuration for the servers we look after, keeping an eye on certificates and supported algorithms.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.cloudflare.com/pq-2025/&quot;&gt;State of the post-quantum Internet in 2025 - Cloudflare Blog&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://csrc.nist.gov/pubs/fips/203/final&quot;&gt;FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard - NIST&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>GDPR from the Infrastructure Side: What It Means in Practice</title><link>https://initd.it/en/changelog/gdpr-infrastructure</link><guid isPermaLink="true">https://initd.it/en/changelog/gdpr-infrastructure</guid><description>What the GDPR means on the technical side: encrypting data at rest and in transit, minimising and retaining logs, access control, secure backups, and where data lives. This is not legal advice.</description><pubDate>Tue, 07 Oct 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The GDPR is often experienced as a matter of forms to sign and privacy notices to publish. That&apos;s part of the story, but not all of it. Many of the regulation&apos;s rules play out on servers, in databases, and in backups: that is, on the infrastructure. People who run systems don&apos;t have to give legal opinions, but it helps to understand which technical choices the regulation asks them to make. This article tries to explain that in plain terms.&lt;/p&gt;
&lt;p&gt;One necessary note before we start: &lt;strong&gt;this is not legal advice&lt;/strong&gt;. It&apos;s a general explanation of the technical side. For the specific obligations in your own case, you need a consultant or your data protection officer.&lt;/p&gt;
&lt;h2&gt;What we&apos;re talking about&lt;/h2&gt;
&lt;p&gt;GDPR stands for General Data Protection Regulation. It&apos;s Regulation (EU) 2016/679, adopted on 27 April 2016 and applicable from 25 May 2018. It concerns the processing of &lt;em&gt;personal data&lt;/em&gt;, meaning any information relating to an identified or identifiable person: a name, an email, an IP address, the details of an order.&lt;/p&gt;
&lt;p&gt;The starting point is simple. If a system stores or moves people&apos;s data, the way it does so is not a matter of indifference. The regulation asks that it be done sensibly and, if something goes wrong, asks that you be able to demonstrate it.&lt;/p&gt;
&lt;h2&gt;The principles that concern the people running the systems&lt;/h2&gt;
&lt;p&gt;Article 5 lists the underlying principles of processing. Three of them touch infrastructure directly.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Data minimisation.&lt;/strong&gt; The data collected must be &quot;adequate, relevant and limited to what is necessary&quot; in relation to the purpose. Translated: you don&apos;t collect everything just in case, only what you genuinely need.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Storage limitation.&lt;/strong&gt; Data must be kept &quot;for no longer than is necessary&quot; for the purpose. In other words, it has an expiry date; it doesn&apos;t pile up forever.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Integrity and confidentiality.&lt;/strong&gt; Data must be processed in a way that ensures appropriate security, including protection against unauthorised access and against accidental loss or destruction.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;There&apos;s then a fourth principle that frames the rest, &lt;strong&gt;accountability&lt;/strong&gt;: whoever processes the data must not only follow the rules but be &quot;able to demonstrate compliance&quot; with them. That&apos;s the reason so many technical choices need to be documented.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your infrastructure meet these technical GDPR principles?&quot; text=&quot;We check encryption, logs, backups, and access control on the systems you run.&quot; button=&quot;Ask for an audit →&quot;}&lt;/p&gt;
&lt;h2&gt;Encryption: data at rest and in transit&lt;/h2&gt;
&lt;p&gt;Article 32 deals with the security of processing. Among the measures it names explicitly are &quot;the pseudonymisation and encryption of personal data&quot;.&lt;/p&gt;
&lt;p&gt;Encrypting means transforming data so that it&apos;s readable only with the right key. In practice there are two moments to distinguish.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;In transit&lt;/strong&gt;, that is, while the data travels across the network. This is the case of a site that uses HTTPS instead of HTTP, or a link between two servers inside an &lt;a href=&quot;/en/changelog/wireguard-vpn&quot;&gt;encrypted tunnel&lt;/a&gt;. Anyone intercepting the traffic sees something go by but can&apos;t read it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;At rest&lt;/strong&gt;, that is, while the data sits still on a disk. If the drive is stolen or a copy ends up in the wrong hands, without the key it stays unreadable, a principle that applies to cloud storage too, where for instance &lt;a href=&quot;/en/changelog/aws-s3-sse-c-default&quot;&gt;S3 changed its default encryption settings&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The same article considers the risks of destruction, loss, alteration, unauthorised disclosure of, or access to data &quot;transmitted, stored or otherwise processed&quot;. From there comes the practical distinction between data in motion and data at rest.&lt;/p&gt;
&lt;h2&gt;Logs: useful, but not forever&lt;/h2&gt;
&lt;p&gt;Logs - the records of what happens on a system - are valuable for understanding problems and reconstructing an incident. But they often contain personal data: an IP address, a username, the time of a login.&lt;/p&gt;
&lt;p&gt;This means the same principles apply to logs too. &lt;strong&gt;Minimisation&lt;/strong&gt;: record what you need, not everything out of habit. &lt;strong&gt;Storage limitation&lt;/strong&gt;: decide how long to keep them, then delete or anonymise them. Keeping logs forever &quot;to be safe&quot; goes in the opposite direction to the one the regulation points to.&lt;/p&gt;
&lt;h2&gt;Access control and traceability&lt;/h2&gt;
&lt;p&gt;A recurring idea is that only those who genuinely need it should be able to reach a piece of data, and only for as long as they need it. On the technical side this translates into concrete things: personal accounts instead of shared credentials, permissions assigned by role, and revoking access when someone changes job or leaves the organisation, perhaps starting from a single watched entry point like a &lt;a href=&quot;/en/changelog/bastion-host&quot;&gt;bastion host&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Alongside control there&apos;s traceability: knowing who did what and when. It helps both to deter misuse and, in the event of an incident, to understand what happened. It&apos;s also one of the tools with which you demonstrate that you acted sensibly.&lt;/p&gt;
&lt;h2&gt;Secure backups&lt;/h2&gt;
&lt;p&gt;Article 32 also names the ability to restore the availability and access to data in a timely manner after a physical or technical incident. In other words: backups aren&apos;t just good practice, they&apos;re part of the required security.&lt;/p&gt;
&lt;p&gt;But a backup is, to all intents and purposes, a copy of the data, and it has to be protected like the original, ideally by following a structured strategy like the &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;3-2-1 backup rule&lt;/a&gt;. If production data is encrypted and the copies aren&apos;t, the protection has a hole. That&apos;s why a backup should be encrypted, kept somewhere safe, and tested: a copy you can&apos;t restore protects no one. The same criterion, with offline copies too, returns in the NIS2 requirements that regulated companies ask of their suppliers: we cover it in &lt;a href=&quot;/en/changelog/nis2-suppliers-what-to-prepare&quot;&gt;NIS2 and suppliers&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;Where the data lives&lt;/h2&gt;
&lt;p&gt;Another question the regulation makes relevant is a simple one: where is the data physically located? The GDPR sets specific conditions for transferring personal data outside the European Union. It&apos;s not a ban, but it does require safeguards.&lt;/p&gt;
&lt;p&gt;For anyone running infrastructure, this translates into concrete choices about &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;how to choose a cloud provider&lt;/a&gt; and the region where the servers run and the backups are kept. Knowing which country the data lives in isn&apos;t a bureaucratic detail: it&apos;s a piece of technical information worth knowing.&lt;/p&gt;
&lt;h2&gt;An approach, not a list of rules&lt;/h2&gt;
&lt;p&gt;It&apos;s tempting to want a fixed checklist of &quot;minimum measures&quot;. The regulation doesn&apos;t work that way. As the Italian data protection authority (the Garante) points out, the list in Article 32 is open and non-exhaustive, and after 25 May 2018 there are no blanket obligations to adopt minimum measures: the choice is left case by case to the controller, in relation to the specific risks. One fixed point remains, though: defending &lt;a href=&quot;/en/changelog/php-end-of-life-risks&quot;&gt;software abandoned by its maker&lt;/a&gt; as adequate is close to impossible.&lt;/p&gt;
&lt;p&gt;This is the idea of protection &quot;by design&quot;, set out in Article 25: data protection should be thought about from the start, when a system is designed, not bolted on at the end. And it should be proportionate to the risk: the data of a neighbourhood forum and the health data of a clinic don&apos;t call for the same precautions.&lt;/p&gt;
&lt;p&gt;One last practical point. If a data breach occurs that poses a risk to people, the controller must notify the supervisory authority &quot;without undue delay and, where feasible, not later than 72 hours&quot; after becoming aware of it. Having logs, backups, and a minimum of procedure ready in advance makes that deadline manageable instead of an emergency.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;On the infrastructure side, the GDPR asks for reasonable things: encrypt data at rest and in motion, collect and keep only what&apos;s necessary, control and trace access, protect backups, and know where the data lives. It isn&apos;t a list to tick once, but a way of designing systems that&apos;s proportionate to the risk and able to account for its own choices. The legal side remains a separate craft: for the obligations in your own case, you need a consultant.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to align your infrastructure with GDPR&apos;s technical requirements?&quot; text=&quot;We work on data encryption, log management, backups, and access control for the servers we administer, coordinating with your data protection officer.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://eur-lex.europa.eu/eli/reg/2016/679/oj/eng&quot;&gt;Regulation (EU) 2016/679 - official text on EUR-Lex&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://gdpr-info.eu/art-5-gdpr/&quot;&gt;Art. 5 GDPR - Principles relating to processing of personal data&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://gdpr-info.eu/art-32-gdpr/&quot;&gt;Art. 32 GDPR - Security of processing&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://gdpr-info.eu/art-33-gdpr/&quot;&gt;Art. 33 GDPR - Notification of a personal data breach (72 hours)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.garanteprivacy.it/misure-di-sicurezza&quot;&gt;Italian Garante - Security measures (Article 32, open list)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>What systemd Is and What Timers Are (the Modern Alternative to cron)</title><link>https://initd.it/en/changelog/systemd-timers</link><guid isPermaLink="true">https://initd.it/en/changelog/systemd-timers</guid><description>systemd is the system and service manager on modern Linux: what it is, what units and timers are, and why timers add integrated logging, dependencies and catch-up over cron.</description><pubDate>Wed, 10 Sep 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;A Linux server is never really idle: behind the scenes, dozens of programs start at boot, sit listening, and get restarted if something goes wrong. Something has to coordinate all of this, decide what to start and in what order, and decide what to do when a program stops working. On most modern Linux systems that &quot;something&quot; is called &lt;strong&gt;systemd&lt;/strong&gt;. Understanding what it is, and what its &lt;em&gt;timers&lt;/em&gt; are, helps you reason about how a Linux machine runs its services and schedules recurring tasks.&lt;/p&gt;
&lt;h2&gt;What systemd is&lt;/h2&gt;
&lt;p&gt;The official documentation defines it plainly: systemd is &quot;a system and service manager for Linux operating systems.&quot; In practice it&apos;s the first program that starts when the machine powers on, technically process number 1 (or &lt;em&gt;PID 1&lt;/em&gt;), and from there it starts and keeps alive all the others. It&apos;s what&apos;s called an &lt;em&gt;init system&lt;/em&gt;: the ancestor from which every other process on the system descends.&lt;/p&gt;
&lt;p&gt;A word on what &quot;service&quot; means here. A service (or &lt;em&gt;daemon&lt;/em&gt;) is a program that runs in the background without an interface you interact with directly: &lt;a href=&quot;/en/changelog/nginx-reverse-proxy&quot;&gt;the web server that answers page requests&lt;/a&gt;, the database, the system that sends email. You don&apos;t &quot;open&quot; it like an app; it starts on its own and stays running. systemd&apos;s job is to start these programs in the right order, keep an eye on them, and restart them when needed.&lt;/p&gt;
&lt;p&gt;systemd is used by most of the widely adopted Linux distributions, which is why it&apos;s worth knowing even in broad strokes: it&apos;s the starting point for understanding how a Linux machine behaves at boot and while it&apos;s running.&lt;/p&gt;
&lt;h2&gt;Units: the building blocks of systemd&lt;/h2&gt;
&lt;p&gt;Everything systemd manages is described by a &lt;strong&gt;unit&lt;/strong&gt;. A unit is simply a text file that describes an object of the system and how to handle it. The documentation lists eleven different types; the most common ones are enough to get the idea:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;.service&lt;/strong&gt; units start and control services (the daemons above);&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;.socket&lt;/strong&gt; units handle network or local connections;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;.mount&lt;/strong&gt; units take care of &lt;a href=&quot;/en/changelog/lvm-storage&quot;&gt;disk mount points&lt;/a&gt;;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;.target&lt;/strong&gt; units group other units or mark well-known milestones in the boot process (for example, &quot;the system is ready for the network&quot;);&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;.timer&lt;/strong&gt; units, the subject of this article, trigger the activation of other units based on time.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The advantage of this scheme is uniformity. Whether it&apos;s a disk, a service, or a scheduled task, the logic is always the same: &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;a file that describes the object&lt;/a&gt;, and a single set of commands to manage it.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do your cron jobs fail silently, with nobody noticing?&quot; text=&quot;We review how recurring tasks are scheduled on your servers and whether failures are actually reported.&quot; button=&quot;Get a review →&quot;}&lt;/p&gt;
&lt;h2&gt;What timers are&lt;/h2&gt;
&lt;p&gt;Here&apos;s the key point, spelled out calmly. A systemd timer &lt;strong&gt;doesn&apos;t run a command&lt;/strong&gt;: it starts another unit at a given moment. By convention a timer activates the service with the same name (&lt;code&gt;backup.timer&lt;/code&gt; starts &lt;code&gt;backup.service&lt;/code&gt;), and the real work, the command to run, lives in that service. The timer only says &lt;em&gt;when&lt;/em&gt;.&lt;/p&gt;
&lt;p&gt;Timers come in two families.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Calendar timers&lt;/strong&gt; fire at a clock time, like &quot;every day at 3:30.&quot; They&apos;re configured with the &lt;code&gt;OnCalendar=&lt;/code&gt; option, whose syntax echoes the idea of cron&apos;s fields but in a more explicit form: day of week, year-month-day, hour:minute:second. An asterisk means &quot;any value.&quot;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;OnCalendar=*-*-* 03:30:00    # every day at 3:30
OnCalendar=Mon..Fri 09:00    # Monday to Friday at 9:00
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;There are also handy shorthands like &lt;code&gt;hourly&lt;/code&gt;, &lt;code&gt;daily&lt;/code&gt;, &lt;code&gt;weekly&lt;/code&gt;, &lt;code&gt;monthly&lt;/code&gt;: for example, &lt;code&gt;daily&lt;/code&gt; corresponds to &lt;code&gt;*-*-* 00:00:00&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Monotonic timers&lt;/strong&gt;, by contrast, don&apos;t look at the clock but at the time elapsed since an event: &lt;code&gt;OnBootSec=&lt;/code&gt; measures from when the machine booted, &lt;code&gt;OnUnitActiveSec=&lt;/code&gt; from when the linked unit was last started. They&apos;re useful for expressing things like &quot;15 minutes after boot, then every hour.&quot;&lt;/p&gt;
&lt;h2&gt;What cron is, and why we talk about an alternative&lt;/h2&gt;
&lt;p&gt;To see why people like timers, it helps to recall what &lt;strong&gt;cron&lt;/strong&gt; does. cron is the long-standing Linux (and Unix) program for scheduling recurring tasks: a daemon that, in the words of its manual, will &quot;run this command at this time on this date.&quot; The schedule is written in a file, the &lt;em&gt;crontab&lt;/em&gt;, with five fields for minute, hour, day of month, month, and day of week.&lt;/p&gt;
&lt;p&gt;cron does one thing, and it has done it reliably for decades: run a command at a time. The catch is everything else, namely where the output goes, what happens if the machine was off at the scheduled time, and how to know when it will run next. Those concerns aren&apos;t cron&apos;s job. systemd timers exist precisely to cover that &quot;everything else.&quot;&lt;/p&gt;
&lt;h2&gt;The advantages of timers&lt;/h2&gt;
&lt;h3&gt;Logs end up in the journal&lt;/h3&gt;
&lt;p&gt;systemd keeps a centralized record of events, the &lt;em&gt;journal&lt;/em&gt;, managed by a service called journald. By default, the output of every service, both normal output and error messages, is collected there and organized by unit. With cron, traditionally, a task&apos;s output was mailed to the user (via the &lt;code&gt;MAILTO&lt;/code&gt; option) or risked being lost. With a timer, a single command reads back the entire history of a task:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;journalctl -u backup.service     # full history of the job
systemctl list-timers            # all timers and their next run
&lt;/code&gt;&lt;/pre&gt;
&lt;h3&gt;Catching up on missed runs&lt;/h3&gt;
&lt;p&gt;With cron, if the machine was off at the scheduled time, that run is simply skipped and nobody records it. Timers offer the &lt;code&gt;Persistent=true&lt;/code&gt; option: systemd stores on disk when the task last ran and, at the next startup, if it should have fired at least once in the meantime, it runs it right away. It&apos;s designed to &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;catch up on missed runs after downtime&lt;/a&gt;, and it applies to calendar timers.&lt;/p&gt;
&lt;h3&gt;Dependencies and ordering&lt;/h3&gt;
&lt;p&gt;A timer starts a unit, and a unit lives inside systemd&apos;s dependency graph. So you can ask for a task to run &quot;only after the network is ready&quot; or &quot;only after a disk is mounted.&quot; cron, by contrast, fires at the time regardless of whether those conditions hold.&lt;/p&gt;
&lt;h3&gt;Verifiability&lt;/h3&gt;
&lt;p&gt;One last practical advantage: you can check everything without waiting for the clock. &lt;code&gt;systemctl list-timers&lt;/code&gt; shows every timer with its next run, and the linked service can be started by hand to test it, independent of the schedule.&lt;/p&gt;
&lt;h2&gt;When cron is still fine&lt;/h2&gt;
&lt;p&gt;It&apos;s not a contest. For a simple task, with no need for structured logs, dependencies, or catch-up, cron is still shorter to write and is available even on systems that don&apos;t use systemd. But when it matters to know &lt;em&gt;what happened&lt;/em&gt;, that is, the output, the outcome, and the next run, or when you need ordering and recovery after an interruption, timers offer a lot more in exchange for one extra file to write.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;systemd is the system and service manager that, on most modern Linux systems, starts and supervises the machine&apos;s programs. It describes everything as a unit, and among those are timers: a way to schedule recurring tasks that, compared to cron, adds logging in the journal, catch-up for missed runs, and dependencies. cron isn&apos;t obsolete, but for anyone who needs to really know what their scheduled jobs are doing, timers are the modern alternative.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want backups and scheduled tasks you can actually monitor?&quot; text=&quot;We set up systemd timers, centralized logging and alerts on the Linux servers we manage, backups included.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://manpages.debian.org/testing/systemd/systemd.1.en.html&quot;&gt;systemd(1) - man page (Debian Manpages)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://manpages.debian.org/testing/systemd/systemd.timer.5.en.html&quot;&gt;systemd.timer(5) - man page (Debian Manpages)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://manpages.debian.org/testing/systemd/systemd.time.7.en.html&quot;&gt;systemd.time(7) - OnCalendar syntax (Debian Manpages)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://manpages.debian.org/testing/systemd/systemd-journald.service.8.en.html&quot;&gt;systemd-journald.service(8) - the journal (Debian Manpages)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://manpages.debian.org/testing/cron/crontab.5.en.html&quot;&gt;crontab(5) - crontab format (Debian Manpages)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Portable passkeys: a standard for moving them between managers</title><link>https://initd.it/en/changelog/fido-credential-exchange</link><guid isPermaLink="true">https://initd.it/en/changelog/fido-credential-exchange</guid><description>The FIDO Alliance has published the Credential Exchange specifications (CXF and CXP) for securely exporting and importing passkeys and other credentials between different managers. Here&apos;s what they are and why they matter against lock-in fears.</description><pubDate>Tue, 19 Aug 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone who started using passkeys instead of passwords soon runs into a practical question: if I decide to switch manager, do my credentials come with me? Until recently the answer was awkward. Passkeys tended to stay trapped in the service where they were born, and there was no secure, shared way to move them elsewhere. The FIDO Alliance, the organization that maintains the standards behind passkeys, has published specifications that tackle exactly this point.&lt;/p&gt;
&lt;h2&gt;Why it matters&lt;/h2&gt;
&lt;p&gt;The fear of being tied to one provider has a common name: &quot;lock-in&quot;. If switching tools means losing your credentials, or exporting them in an insecure way, many people prefer not to move at all. Or they keep the old password as a safety net. And as long as the password stays as a fallback, most of the benefits of passkeys remain on paper. Making credential transfer a supported, secure operation isn&apos;t a technical detail: it&apos;s one of the knots that decide whether passkeys become &lt;a href=&quot;/en/changelog/passkey-cross-platform&quot;&gt;a mainstream sign-in method&lt;/a&gt; or stay a convenience for the few.&lt;/p&gt;
&lt;h2&gt;What a passkey is, briefly&lt;/h2&gt;
&lt;p&gt;A passkey is a way to sign in to a site or an app without typing a password. Instead of a secret word it uses a pair of cryptographic keys: two mathematical values tied to each other. One, the private key, stays on the user&apos;s device and is never shared. The other, the public key, is handed to the site during registration. When you sign in, the device signs a small &quot;challenge&quot; sent by the site, but only after the user has unlocked as usual: fingerprint, face recognition, or PIN.&lt;/p&gt;
&lt;p&gt;The benefit is twofold. There&apos;s no longer a password to steal, because the site only keeps the public key, which on its own lets no one in and isn&apos;t open to a &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;brute force attack&lt;/a&gt; either. And phishing attempts, the fake pages that imitate a service to get you to type your credentials, stop working, because the passkey is bound to the site&apos;s real address. Passkeys are usually saved and synced by a &quot;credential manager&quot;: it can be the one built into the operating system, like Apple Passwords or Google Password Manager, or a dedicated app like 1Password or Bitwarden.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your application already support passkeys for sign-in?&quot; text=&quot;We assess your current authentication and what&apos;s needed to add or replace passwords.&quot; button=&quot;Ask for an assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;The problem: no secure way to move them&lt;/h2&gt;
&lt;p&gt;So far, the solid part. The weak spot was portability. Each manager kept passkeys inside its own fence, and moving from one to another was hard. With old passwords there was at least a path, but a poor one: exporting them to a text file, often in the clear, that is, readable by anyone who opened it. For passkeys there wasn&apos;t even that. A standard was missing entirely, meaning a shared format and procedure that every manager could adopt.&lt;/p&gt;
&lt;p&gt;The result is exactly the lock-in described above. Without a secure way out, users feel trapped, and trust in a new technology suffers.&lt;/p&gt;
&lt;h2&gt;What the FIDO Alliance published&lt;/h2&gt;
&lt;p&gt;To address this, the FIDO Alliance defined two complementary specifications, grouped under the name Credential Exchange.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Credential Exchange Format (CXF)&lt;/strong&gt;: this is the format. It sets out how the data to be transferred should be described, with a common structure based on JSON (a widespread, human-readable way of organizing data). It isn&apos;t only about passkeys: it also covers passwords, SSH keys, Wi-Fi credentials, and other kinds of secret. The idea is that exported data looks the same regardless of which manager produced it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Credential Exchange Protocol (CXP)&lt;/strong&gt;: this is the protocol, the &quot;how&quot;. It defines the way the transfer happens between two managers, encrypted and secure by default, the same principle behind &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;encrypting data in transit&lt;/a&gt; that&apos;s required of systems handling personal data. The stated goal is that credentials no longer travel in the clear.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;In short: CXF says &lt;em&gt;what&lt;/em&gt; is transferred, CXP says &lt;em&gt;how&lt;/em&gt; it&apos;s transferred.&lt;/p&gt;
&lt;p&gt;An important point to grasp: these specifications don&apos;t move the passkeys for you. They&apos;re a common language. They exist so that two different managers, from different companies, can talk to each other and hand over credentials without each inventing its own method every time.&lt;/p&gt;
&lt;h2&gt;Where the specifications stand&lt;/h2&gt;
&lt;p&gt;Here some honesty about timing is needed, because the two specifications aren&apos;t at the same stage.&lt;/p&gt;
&lt;p&gt;The first drafts of CXF and CXP were published on October 14, 2024, open to community feedback and not yet ready for real use. Work continued from there. On August 14, 2025 the CXF format was published as a Proposed Standard, that is, a first stable version (1.0) that managers can begin to implement. That&apos;s a different step from a plain draft: it marks a fixed point to build on.&lt;/p&gt;
&lt;p&gt;The CXP protocol, on the other hand, is still in draft at the time of writing. In practice, the format for describing credentials exists and is settled; the secure procedure for transferring them directly between managers is still being defined. It&apos;s a useful distinction, so the announcement isn&apos;t read as &quot;from tomorrow I&apos;ll move everything with one click&quot;.&lt;/p&gt;
&lt;p&gt;It&apos;s worth noting who is behind this. The specifications come from a FIDO Alliance working group dedicated to credential providers, with contributions from very familiar names: among others 1Password, Apple, Bitwarden, Dashlane, Enpass, Google, Microsoft, NordPass, Okta, Samsung, and SK Telecom. That detail matters: a portability standard only makes sense if it&apos;s adopted by the very managers users want to move between.&lt;/p&gt;
&lt;h2&gt;What to expect, realistically&lt;/h2&gt;
&lt;p&gt;A published standard isn&apos;t yet a feature ready in your manager. For it to become something people actually use, each provider has to implement it in its products, and the timing varies from one to another. That said, the direction is clear: to make exporting and importing credentials a secure, expected operation, instead of an obstacle course or a file readable in the clear.&lt;/p&gt;
&lt;p&gt;For the everyday user the benefit, once it&apos;s fully in place, is concrete: being able to change credential manager with the same freedom you now switch phone carrier while keeping your number. It&apos;s precisely the lack of this freedom that kept many people still.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;The FIDO Alliance has defined a standard for moving credentials between different managers securely: CXF for the data format and CXP for the transfer protocol. The format reached a first stable version in August 2025; the protocol is still in progress. It isn&apos;t a feature available everywhere yet, but it&apos;s the missing piece for removing the lock-in fear, one of the main brakes on passkey adoption.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to bring passkeys into your application?&quot; text=&quot;We design and integrate passwordless authentication into the Laravel and Vue applications we build, weighing security and compatibility with the major managers.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://fidoalliance.org/specifications-credential-exchange-specifications/&quot;&gt;FIDO Credential Exchange Specifications (FIDO Alliance)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://fidoalliance.org/fido-alliance-publishes-new-specifications-to-promote-user-choice-and-enhanced-ux-for-passkeys/&quot;&gt;FIDO Alliance Publishes New Specifications to Promote User Choice and Enhanced UX for Passkeys (FIDO Alliance)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.1password.community/blog/developer-blog/portability-without-compromise-1password-helps-author-a-new-standard-for-secure-/163208&quot;&gt;Portability without compromise: 1Password helps author a new standard for secure credential transfer (1Password)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>What LVM Is and Why It Simplifies Disk Management on Linux</title><link>https://initd.it/en/changelog/lvm-storage</link><guid isPermaLink="true">https://initd.it/en/changelog/lvm-storage</guid><description>What LVM is, the layer that sits between disks and data: physical volume, volume group and logical volume explained with an analogy, and the benefits over classic partitions.</description><pubDate>Thu, 14 Aug 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone who installs a Linux server or computer eventually faces a question that only looks trivial: how to divide up the disk. With the traditional method that decision has to be made almost right away, and it&apos;s awkward to change later. It only takes one part of the disk filling up while another sits half empty to see the limit. LVM exists precisely to make that choice reversible. Understanding what it is helps you reason about disk space without treating it as a cage decided once and for all.&lt;/p&gt;
&lt;h2&gt;Before LVM: the problem of fixed partitions&lt;/h2&gt;
&lt;p&gt;A disk usually isn&apos;t used as one single block: it&apos;s split into &lt;strong&gt;partitions&lt;/strong&gt;, that is, slices of space with a well-defined boundary. One slice for the system, one for data, one for swap, and so on. The catch is that, with classic partitions, that boundary is carved into the disk: it says &quot;this slice goes up to here and no further.&quot; As long as the guesses made at the start hold up, everything is fine. When they stop holding, moving a boundary on a running system is a delicate operation, often done with the machine switched off, with a real risk of losing data.&lt;/p&gt;
&lt;p&gt;The typical result is a kind of waste anyone who has managed a disk knows well: a partition full at 100% blocking a service, while right next to it another one is only half used. The free space is there, but it&apos;s on the wrong side of the wall.&lt;/p&gt;
&lt;h2&gt;What LVM is, in plain terms&lt;/h2&gt;
&lt;p&gt;LVM stands for &lt;em&gt;Logical Volume Manager&lt;/em&gt;. It&apos;s a component shipped by default in the most common Linux distributions, and its idea is simple: put an &lt;strong&gt;intermediate layer&lt;/strong&gt; between the physical disks and the file systems (the way data is organized, written and read). Instead of having the data talk directly to the disk, you talk to LVM, which keeps the accounting of the space and decides how to hand it out.&lt;/p&gt;
&lt;p&gt;That extra layer is the whole point. By adding a level of abstraction, the boundaries of space stop being fixed: they become numbers managed in software, which can be moved while the system keeps working. Oracle Linux&apos;s documentation puts it well when it describes LVM as &quot;non disruptive and transparent to users,&quot; so that operations like enlarging a volume or reorganizing disks &quot;don&apos;t require any system down time.&quot;&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Worried about ending up with one disk full while another sits half empty?&quot; text=&quot;We review your servers&apos; storage and assess whether moving to LVM makes sense, without stopping any services.&quot; button=&quot;Ask for an assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;The three core concepts: physical volume, group, logical volume&lt;/h2&gt;
&lt;p&gt;LVM rests on three concepts stacked on top of each other. Clearing them up right away removes most of the confusion. A useful analogy is that of a warehouse.&lt;/p&gt;
&lt;p&gt;The &lt;strong&gt;physical volume&lt;/strong&gt; (PV) is the lowest layer: a disk or a partition you declare &quot;usable by LVM.&quot; It&apos;s like bringing crates of raw goods into the warehouse. LVM splits their space into many equally sized blocks, called &lt;em&gt;extents&lt;/em&gt; (Oracle&apos;s documentation lists a default size of 4 MB), which are the unit it uses to count everything from then on.&lt;/p&gt;
&lt;p&gt;The &lt;strong&gt;volume group&lt;/strong&gt; (VG) is the warehouse itself: it pools one or more physical volumes into a single large reservoir of space. This is where the flexibility lives. The reservoir doesn&apos;t care whether the space comes from a single disk or from five different ones: it sees them as one supply.&lt;/p&gt;
&lt;p&gt;The &lt;strong&gt;logical volume&lt;/strong&gt; (LV) is what you actually use: from the reservoir you carve out a volume of the size you want, put a file system on it and mount it like a normal drive. To the system it&apos;s indistinguishable from a partition, with the key difference that its boundaries aren&apos;t fixed. Back to the analogy: the walls between the rooms of the warehouse aren&apos;t made of bricks, but of movable panels you can shift when needed, without emptying everything out.&lt;/p&gt;
&lt;p&gt;The full path, from disks to ready-to-use space, is a sequence of three steps:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;pvcreate /dev/sdb /dev/sdc      # mark two disks as physical volumes
vgcreate data /dev/sdb /dev/sdc # pool them into a group called &quot;data&quot;
lvcreate -L 50G -n web data     # carve out a 50 GB logical volume
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;From here you create a file system on the volume and mount it, exactly as you would with a partition.&lt;/p&gt;
&lt;h2&gt;What changes compared to classic partitions&lt;/h2&gt;
&lt;p&gt;The practical benefits of this model are few and concrete.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Resizing on the fly.&lt;/strong&gt; If a logical volume fills up and the group still has free space, you can enlarge it while the system is running, without unmounting anything and without stopping services. In many cases, with a single option, the file system on top is grown at the same moment. One detail worth knowing: enlarging a file system can almost always be done live, but &lt;em&gt;shrinking&lt;/em&gt; one is more delicate and often requires unmounting it first. Some file systems, such as XFS, can only be grown, not reduced.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Combining multiple disks into one space.&lt;/strong&gt; Because the group adds up the capacity of all the physical volumes it contains, a file system can span several disks as if they were one. When space runs short, you just add a disk to the group to increase its capacity, without rebuilding the existing structure.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Snapshots.&lt;/strong&gt; A &lt;em&gt;snapshot&lt;/em&gt; is a frozen picture of a volume at a specific moment. LVM&apos;s manual page describes it as a &quot;frozen image of an origin LV&quot; that can be used, for example, for backups while the original volume keeps being used, following the same redundancy logic laid out in &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;the 3-2-1 backup rule&lt;/a&gt;. It&apos;s handy for copying a database or a system without stopping it, avoiding saving files that change while the copy is still in progress, something worth scheduling in production with &lt;a href=&quot;/en/changelog/systemd-timers&quot;&gt;a timer that runs on a fixed schedule&lt;/a&gt; rather than kicking it off by hand. In LVM a snapshot can also be &quot;merged back&quot; into its origin, returning the volume to the state it was in when the snapshot was taken: a convenient safety net before a risky update. In the virtualization world, snapshots on shared LVM volumes were a long-standing limitation, lifted only recently: it is one of the new features we discuss when covering &lt;a href=&quot;/en/changelog/proxmox-8-end-of-life-upgrade&quot;&gt;the move from Proxmox VE 8 to 9&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Moving data between disks without stopping anything.&lt;/strong&gt; If a disk starts showing signs of failure, or if you&apos;re moving from a spinning drive to a solid-state one, LVM lets you transfer data from one physical volume to another while the volumes stay mounted and in use. Once the transfer is done, the old disk is removed from the group and can be physically pulled out.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;When it&apos;s worth using (and when it isn&apos;t)&lt;/h2&gt;
&lt;p&gt;LVM isn&apos;t free: it adds an extra layer to understand and, if something goes wrong, to know how to recover. On a USB stick or a single-purpose, fixed-size disk it&apos;s needless complexity that doesn&apos;t pay off. It&apos;s also worth remembering that the small system boot partition (boot and EFI) stays a classic partition anyway: LVM doesn&apos;t replace it.&lt;/p&gt;
&lt;p&gt;On servers, though, the scale almost always tips the other way. Whenever you expect to have to grow space over time, move data between disks, or take consistent backups without stopping services, LVM&apos;s flexibility repays its small upfront cost, the same reasoning behind preferring &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;infrastructure described in versioned files&lt;/a&gt; over one configured by hand once and for all. The most common rule of thumb is simple: a classic partition only where it&apos;s mandatory, everything else under LVM. Better to have the flexibility and not use it than to discover you need it with the disk already full.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;LVM is a layer of abstraction that sits between the physical disks and the data. It turns the rigid boundaries of partitions into numbers managed in software: disks become physical volumes, they pool into a group that acts as a reservoir, and from there you carve out logical volumes with movable walls. The concrete payoff is being able to resize on the fly, combine multiple disks, freeze snapshots for backups, and move data with no downtime. It isn&apos;t needed everywhere, but where space has to be able to change over time, it keeps you from treating a first-day decision as if it were final.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to manage your servers&apos; storage without the risk of running out of space?&quot; text=&quot;We manage Linux disks and volumes on servers and cloud instances: migration to LVM, snapshots for backups and live resizing, with no downtime.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.oracle.com/en/operating-systems/oracle-linux/8/stordev/stordev-WorkingWithLogicalVolumeManager.html&quot;&gt;Working With Logical Volume Manager - Oracle Linux&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://ubuntu.com/server/docs/how-to/storage/manage-logical-volumes/&quot;&gt;How to manage logical volumes - Ubuntu Server documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://man7.org/linux/man-pages/man8/lvcreate.8.html&quot;&gt;lvcreate(8) - man7.org&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Pay per crawl: charging AI crawlers with HTTP 402</title><link>https://initd.it/en/changelog/pay-per-crawl</link><guid isPermaLink="true">https://initd.it/en/changelog/pay-per-crawl</guid><description>Cloudflare proposes a third option beyond blocking or allowing AI crawlers: charging them for access to your content using the HTTP 402 status code. How it works and why it matters.</description><pubDate>Tue, 08 Jul 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone who publishes content online has long faced a stark choice when the AI &quot;crawlers&quot; show up. A crawler is an automated program that downloads web pages: the ones run by AI companies do this to train their models or to gather material for answering user questions. Until recently, site owners had only two options: let them through for free, or shut them out. In early July 2025, Cloudflare - a large network infrastructure company that sits between a huge share of web traffic and the sites behind it - proposed a third path: make them pay. The mechanism is called &quot;pay per crawl&quot;, and it revives an almost-never-used HTTP code: 402, &quot;Payment Required&quot;.&lt;/p&gt;
&lt;h2&gt;The problem: block everything, or give it all away&lt;/h2&gt;
&lt;p&gt;To see why this matters to people who produce content, it helps to start with the context. A site that hosts articles, photos or data costs money to produce and to keep online. When an AI company&apos;s crawler downloads that material, it effectively takes it and leaves nothing behind: no human visit, no ad seen, no subscription.&lt;/p&gt;
&lt;p&gt;The traditional tool for managing crawlers is the &lt;code&gt;robots.txt&lt;/code&gt; file, a simple list of rules where a site declares &quot;you may download this, not that&quot;. It has two limits, though. First, it&apos;s only a polite request: it stops no one who decides to ignore it. Second, it speaks a binary language, yes or no. There&apos;s no &quot;yes, but for a fee&quot; box.&lt;/p&gt;
&lt;p&gt;The result is an uncomfortable ultimatum for publishers. Blocking crawlers entirely means giving up any return and, sometimes, vanishing from AI-generated answers. Leaving them free means giving your work away. Cloudflare says it heard this frustration from news organizations, publishers and large platforms: many would like a third option, allowing access but being compensated for it.&lt;/p&gt;
&lt;h2&gt;What pay per crawl is&lt;/h2&gt;
&lt;p&gt;Pay per crawl is exactly that third option. For each crawler, a site owner can choose among three behaviors:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Allow&lt;/strong&gt; - free, open access, as before.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Charge&lt;/strong&gt; - access is granted, but at a set price.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Block&lt;/strong&gt; - access denied, with no option to pay.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The core idea is simple: turn crawler access into a small economic transaction, without having to negotiate case by case with every AI company. For now the price is a single figure that applies across the whole domain: you set an amount per successful request, and it covers every page.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do you actually know which AI crawlers are downloading your site&apos;s content?&quot; text=&quot;We review your robots.txt, WAF and Cloudflare rules to see who&apos;s really accessing your content.&quot; button=&quot;Get a review →&quot;}&lt;/p&gt;
&lt;h2&gt;How it works: the return of HTTP 402&lt;/h2&gt;
&lt;p&gt;Here&apos;s the technical part, kept simple. Every time a browser or a program asks a server for a page, the server replies with a &quot;status code&quot;: a number that sums up how it went. 200 means &quot;all good, here&apos;s the content&quot;; 404 means &quot;not found&quot;; 403 means &quot;forbidden&quot;. Among these there&apos;s one, &lt;strong&gt;402 &quot;Payment Required&quot;&lt;/strong&gt;, defined since the earliest versions of the HTTP standard but kept on the shelf for years, &lt;a href=&quot;/en/changelog/http-deprecation-header&quot;&gt;waiting for a concrete use&lt;/a&gt;. Pay per crawl is one of those uses.&lt;/p&gt;
&lt;p&gt;The exchange, simplified, works like this. A crawler asks for a paid page without offering anything: the server replies with a &lt;strong&gt;402&lt;/strong&gt; and adds a header (a line of metadata that travels with the response) called &lt;code&gt;crawler-price&lt;/code&gt;, the amount being asked. At that point the crawler, if it accepts, repeats the request stating how much it&apos;s willing to pay through the &lt;code&gt;crawler-exact-price&lt;/code&gt; header. If everything checks out, the server responds with a &lt;strong&gt;200&lt;/strong&gt; and the content, adding &lt;code&gt;crawler-charged&lt;/code&gt; to confirm the amount billed.&lt;/p&gt;
&lt;p&gt;There&apos;s also a more direct route: the crawler can declare a spending cap in its very first request using the &lt;code&gt;crawler-max-price&lt;/code&gt; header. If the site&apos;s price falls within that cap, the content arrives immediately, with the charge confirmed. In practice the 402 isn&apos;t an error to avoid but a way of saying &quot;you can have this, but it costs X&quot;: a kind of price tag returned on the fly by the server.&lt;/p&gt;
&lt;h2&gt;Telling a paying crawler apart&lt;/h2&gt;
&lt;p&gt;A scheme like this only holds up if the server knows for certain who it&apos;s dealing with; otherwise anyone could pose as an authorized crawler. That&apos;s why pay per crawl relies on &lt;a href=&quot;/en/changelog/web-bot-auth&quot;&gt;cryptographic signatures&lt;/a&gt;. Each participating crawler holds a key pair (a private one, kept secret, and a public one, shared) and signs its requests with the private key; the server verifies the signature with the public key. It&apos;s the same principle that makes many secure communications on the web trustworthy: the signature proves identity and guarantees the request wasn&apos;t tampered with along the way. This ties the charge to a recognized sender, not an anonymous one.&lt;/p&gt;
&lt;h2&gt;Who collects and who pays: Cloudflare as the middleman&lt;/h2&gt;
&lt;p&gt;One practical problem remained: no publisher wants to handle micro-payments from dozens of AI companies, and no AI company wants to open an account with every single site. Cloudflare steps in as the &quot;merchant of record&quot;, the party that appears as the official seller in the transaction. In practice it collects the charges as they accrue, bills the crawler operators and passes the proceeds to publishers. For the site, this means not having to build a payment system from scratch; for the crawler, a single counterpart instead of a thousand.&lt;/p&gt;
&lt;p&gt;It should be said plainly: to use pay per crawl you have to be a Cloudflare customer and route your site through its network. It&apos;s a commitment to one provider, not an open standard anyone can adopt on their own.&lt;/p&gt;
&lt;h2&gt;What changes for content creators&lt;/h2&gt;
&lt;p&gt;The value of the proposal isn&apos;t the individual payment, which on its own will often be tiny, but the fact that it finally puts a price on something you could previously only give away or deny. For a news outlet, or for anyone running a rich, constantly updated archive, being able to say &quot;you&apos;re welcome here, but this work has a cost&quot; is a shift in perspective, if only as bargaining leverage.&lt;/p&gt;
&lt;p&gt;Expectations should stay sober, though. The mechanism only works if AI companies choose to take part and pay, rather than simply not downloading the site. A single price for the whole domain is still inflexible. And the entire structure lives inside one vendor&apos;s infrastructure. These are the things that make it an interesting experiment more than a mature solution.&lt;/p&gt;
&lt;h2&gt;It&apos;s a beta, and it&apos;s eyeing &quot;agents&quot;&lt;/h2&gt;
&lt;p&gt;Precision matters here: at the time of the announcement, pay per crawl is in &lt;strong&gt;private beta&lt;/strong&gt;. It isn&apos;t an open service or a settled standard; to try it you have to sign up and go through restricted access. The headers, prices and rules described here are those of the early phase and may change as the experiment progresses.&lt;/p&gt;
&lt;p&gt;There is, however, a broader direction that explains why the news drew attention. Cloudflare frames it within a larger scenario, that of &quot;&lt;a href=&quot;/en/changelog/agent-skills&quot;&gt;agents&lt;/a&gt;&quot; - AI programs acting on a person&apos;s behalf. The idea, openly forward-looking, is that one day you might hand an assistant a budget and let it independently buy the best content for a task. Whether that future arrives or not, today&apos;s concrete signal is more modest but not trivial: taking a forgotten piece of the HTTP standard, the 402 code, and trying to use it to put a price back on automated access to content.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to manage how AI crawlers access your site?&quot; text=&quot;We configure Cloudflare, access rules and traffic monitoring for the sites and online stores we manage.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.cloudflare.com/introducing-pay-per-crawl/&quot;&gt;Introducing pay per crawl (Cloudflare Blog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developers.cloudflare.com/ai-crawl-control/features/manage-ai-crawlers/&quot;&gt;Manage AI crawlers (Cloudflare AI Crawl Control docs)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.cloudflare.com/paypercrawl-signup/&quot;&gt;Cloudflare Pay Per Crawl - Private Beta (sign-up)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>What a Bastion Host Is and Why It Makes SSH Access Safer</title><link>https://initd.it/en/changelog/bastion-host</link><guid isPermaLink="true">https://initd.it/en/changelog/bastion-host</guid><description>What a bastion host (or jump host) is: the single controlled entry point into a private network, why it shrinks the attack surface, and where it fits in an SSH architecture.</description><pubDate>Tue, 08 Jul 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;To manage a server remotely, you almost always use &lt;strong&gt;SSH&lt;/strong&gt; (&lt;em&gt;Secure Shell&lt;/em&gt;), a protocol that lets you connect to a machine and run commands from another computer, over an encrypted channel. As long as you have one or two servers, managing that access is easy. The trouble starts when they become ten, fifty, or a hundred. Opening SSH access to each of them from the internet means leaving that many doors open, and every door is something to watch. The &lt;strong&gt;bastion host&lt;/strong&gt; is the most common answer to this: instead of exposing every server, you expose just one, controlled, and you pass through it.&lt;/p&gt;
&lt;h2&gt;What a bastion host is&lt;/h2&gt;
&lt;p&gt;A bastion host (often also called a &lt;em&gt;jump host&lt;/em&gt; or &lt;em&gt;jump box&lt;/em&gt;) is a machine that acts as the single entry point into a private network. The &lt;strong&gt;NIST&lt;/strong&gt; glossary - NIST is the US agency that publishes information-security standards - defines it as a special-purpose computer on a network, specifically designed and configured to withstand attacks.&lt;/p&gt;
&lt;p&gt;The underlying idea is simple. Nobody connects to the internal servers directly. You connect to the bastion first and, from there, reach your destination. The internal servers, for their part, accept SSH connections only from the bastion and from nowhere else. It&apos;s the machine on the front line: the only one reachable from outside and, precisely for that reason, the one kept with the most care.&lt;/p&gt;
&lt;h2&gt;The problem: exposing every server&lt;/h2&gt;
&lt;p&gt;To see why it&apos;s needed, the notion of &lt;strong&gt;attack surface&lt;/strong&gt; helps: the set of all the points from which someone could try to get in. Every server with its SSH port open to the internet is one of those points. And it isn&apos;t a theoretical risk: any public address receives &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;constant automated login attempts, run by programs that try credentials one after another&lt;/a&gt; hoping to guess a working one.&lt;/p&gt;
&lt;p&gt;With a single server, that&apos;s a manageable problem. With twenty, it becomes unmanageable, for three reasons that pile up:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Maintenance.&lt;/strong&gt; Every exposed machine has to be updated, watched, and kept aligned with the same rules. Keeping twenty servers perfectly in sync is far harder than keeping one.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Traceability.&lt;/strong&gt; If access is possible everywhere, the record of who logged in is scattered across twenty different systems. Answering &quot;who connected to that server last night?&quot; turns into a small investigation.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Authentication.&lt;/strong&gt; Raising the defenses - for instance by adding a second verification factor - has to be done on every machine. The same work twenty times, with twenty chances to get it wrong.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The attack surface, in short, grows with the number of open doors. Reducing that number is a defense in itself: when the defect is in the kernel, as with &lt;a href=&quot;/en/changelog/cve-2026-98432-linux-kernel-tcp-what-to-do&quot;&gt;the CVE-2026-98432 flaw in Linux&apos;s TCP code&lt;/a&gt;, every reachable IPv4 TCP port is a target regardless of the service behind it.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;How many of your company&apos;s servers still have SSH open to the internet?&quot; text=&quot;We check which machines are directly exposed and assess whether a bastion host would genuinely cut the risk.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;A single entry point: how it works&lt;/h2&gt;
&lt;p&gt;A useful comparison is the reception desk of a building with many offices. Visitors don&apos;t walk in through any door: they go through reception, identify themselves, sign the register. Only then do they reach the right office. If someone wants to check who came in and when, they look at one register, not twenty.&lt;/p&gt;
&lt;p&gt;The bastion host is that reception desk. It concentrates in one place the operations that would otherwise have to be repeated everywhere: verifying the identity of whoever connects, deciding who may enter and from where, logging every access. The internal servers don&apos;t need to worry about it, because they trust that anyone reaching them has already passed the check at the border.&lt;/p&gt;
&lt;h2&gt;Why it shrinks the attack surface&lt;/h2&gt;
&lt;p&gt;That&apos;s the main benefit: from many exposed doors you go down to one. Instead of defending twenty machines to the same standard, you defend one of them well, and the rest stay unreachable from outside.&lt;/p&gt;
&lt;p&gt;On that one machine, then, it&apos;s best to keep the bare minimum. A well-built bastion doesn&apos;t host websites, databases, or other services: its only job is to pass connections through. The less software runs on a machine, the fewer possible weak spots it has. NIST makes the same point: bastion hosts, having to sit on the front line, are usually configured with as few active services as possible, the same principle behind &lt;a href=&quot;/en/changelog/aws-s3-sse-c-default&quot;&gt;turning off rarely used features by default&lt;/a&gt;, precisely to reduce their attack surface.&lt;/p&gt;
&lt;h2&gt;Access logged and verified in one place&lt;/h2&gt;
&lt;p&gt;Concentrating the entry point brings two benefits that are worth the effort on their own.&lt;/p&gt;
&lt;p&gt;The first is &lt;strong&gt;traceability&lt;/strong&gt;. If every access goes through a single host, the records (the &lt;em&gt;logs&lt;/em&gt;) of who enters, when, and under which identity are all in one place, a requirement that lines up well with the &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;accountability required under GDPR&lt;/a&gt;. By shipping them in real time to a separate collection system, the trail stays safe even if the bastion were ever compromised. The question &quot;who connected last night?&quot; becomes a search through the logs, not an investigation.&lt;/p&gt;
&lt;p&gt;The second is &lt;strong&gt;strong authentication&lt;/strong&gt;. A widely used way to make access safer is &lt;strong&gt;MFA&lt;/strong&gt; (&lt;em&gt;Multi-Factor Authentication&lt;/em&gt;): on top of the usual credential, a second element is required - for example a temporary code generated by an app on your phone. Even if someone stole the password, they wouldn&apos;t get in without the second factor. With a bastion, this protection is set up once, at the entry point, instead of being configured on every server. Automated access is a separate story, though: a script or a release procedure cannot type a second factor, so the answer there is a different one, and you will find it in &lt;a href=&quot;/en/changelog/pipeline-secrets&quot;&gt;how pipeline credentials should be stored&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;ProxyJump: crossing the bastion the right way&lt;/h2&gt;
&lt;p&gt;For years the &quot;jump&quot; through the bastion was done by hand: you connected to the bastion and from there ran a second SSH command toward the internal server. It works, but it&apos;s clumsy and it isn&apos;t the better choice from a security standpoint, because the connection to the final destination is created and lives on the most exposed machine.&lt;/p&gt;
&lt;p&gt;Since version 7.3, OpenSSH (the most widely used SSH implementation) offers a dedicated option, &lt;strong&gt;ProxyJump&lt;/strong&gt;, with its &lt;code&gt;-J&lt;/code&gt; flag. The release notes describe it plainly: it adds a ProxyJump option and the &lt;code&gt;-J&lt;/code&gt; command to simplify indirect access through one or more bastions, or &quot;jump hosts.&quot; From the user&apos;s side, the jump becomes an invisible detail:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# One command: the hop through the bastion is automatic
ssh -J bastion.example.com internal-server.lan
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Better still, you can save the configuration in your computer&apos;s &lt;code&gt;~/.ssh/config&lt;/code&gt; file and forget about it:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Host internal-server
    HostName 10.0.5.20
    ProxyJump bastion.example.com
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The difference isn&apos;t only convenience. With ProxyJump the bastion simply forwards the data toward the destination, while the SSH connection stays encrypted end to end between your computer and the internal server. In practice the bastion passes along data it can&apos;t read. What to avoid, instead, is the &lt;em&gt;agent forwarding&lt;/em&gt; shortcut, which would make your access key usable by the bastion itself: the official documentation advises using it with caution, which is why it&apos;s turned off by default.&lt;/p&gt;
&lt;h2&gt;Where it fits in an architecture&lt;/h2&gt;
&lt;p&gt;A bastion only works if the network is organized around it. The typical setup relies on &lt;strong&gt;segmentation&lt;/strong&gt;: the bastion lives in an exposed, controlled zone (often called a DMZ or public subnet), while the actual servers sit in a private zone that isn&apos;t reachable directly from the internet. A firewall enforces the rule that makes everything else true: toward those servers, SSH connections are accepted only if they come from the bastion.&lt;/p&gt;
&lt;p&gt;Without that separation, the bastion would be a reinforced door next to an open window: anyone could bypass it by connecting straight to the servers. With segmentation, the only route inward runs through the controlled border.&lt;/p&gt;
&lt;p&gt;There&apos;s a trade-off to keep in mind: by concentrating everything in one place, that place becomes critical. If the bastion is misconfigured or stops working, access to everything is blocked. That&apos;s why it has to be kept minimal, updated, and watched with particular care: the same goes for routers, as the &lt;a href=&quot;/en/changelog/mikrotik-routeros-ssh-vulnerabilities&quot;&gt;MikroTik RouterOS SSH flaws&lt;/a&gt; exploited on devices with exposed management show. A bastion isn&apos;t the only way to solve the problem - &lt;a href=&quot;/en/changelog/wireguard-vpn&quot;&gt;a VPN&lt;/a&gt;, for example, tackles the same need from another angle - but it remains one of the simplest and most common.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;A bastion host is a funnel: it forces every access through a single point, where you concentrate the defenses it would be absurd to replicate everywhere. It shrinks the attack surface because, instead of many exposed doors, it leaves one well-protected door; it makes access traceable because it gathers it into a single register; and it lets you raise authentication once and for all rather than machine by machine. Crossing it with ProxyJump also makes it convenient and safe to use. It isn&apos;t a magic solution, and it needs a segmented network to really work, but it&apos;s one of the sturdiest ways to bring order to access that has grown out of control.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to secure SSH access to your infrastructure?&quot; text=&quot;We design and manage access architectures with bastion hosts, network segmentation and multi-factor authentication for our clients&apos; Linux servers.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://csrc.nist.gov/glossary/term/bastion_host&quot;&gt;Bastion host - NIST Computer Security Resource Center Glossary&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.openssh.com/txt/release-7.3&quot;&gt;OpenSSH 7.3 release notes - introducing ProxyJump and the -J flag&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://man.openbsd.org/ssh_config&quot;&gt;ssh_config(5) - ProxyJump and ForwardAgent options, OpenSSH man page&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Serverless GPUs on Cloud Run: paying for inference only when you need it</title><link>https://initd.it/en/changelog/cloud-run-gpu</link><guid isPermaLink="true">https://initd.it/en/changelog/cloud-run-gpu</guid><description>Google has made GPU support on Cloud Run generally available, with scale-to-zero and per-second billing. What it means to serve AI models without keeping a cluster running, and what to weigh.</description><pubDate>Mon, 30 Jun 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;In June 2025 Google brought GPU support on Cloud Run, its &quot;serverless&quot; service, to general availability. In plain terms: you can serve an artificial-intelligence model on a graphics card that turns on only when a request arrives and shuts off when there&apos;s nothing to do, paying only for the seconds actually used. It sounds like a technical detail, but it touches a cost that weighs heavily today. It&apos;s worth explaining, without needless jargon, what changes and when it&apos;s genuinely worth it.&lt;/p&gt;
&lt;h2&gt;A word on the terms: &quot;GPU&quot;, &quot;inference&quot;, &quot;serverless&quot;&lt;/h2&gt;
&lt;p&gt;A &lt;strong&gt;GPU&lt;/strong&gt; is a graphics card: a kind of processor born for video games, able to do a great many calculations in parallel. That&apos;s exactly why it became the standard tool for artificial intelligence, which is largely made of repeated calculations over large amounts of numbers.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Inference&lt;/strong&gt; means using a model that has already been trained: you&apos;re not teaching it, you&apos;re just asking it something and waiting for the answer. When you write to an assistant and it replies, that&apos;s inference at work. It needs a GPU to happen quickly.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Serverless&lt;/strong&gt; is the rental model behind all this. It doesn&apos;t mean &quot;no servers&quot;: the servers are there, but you don&apos;t rent them for a fixed amount of time. You hand your program to the provider, which starts it when a request arrives and stops it when traffic drops, billing only the compute time consumed. &lt;strong&gt;Cloud Run&lt;/strong&gt; is Google&apos;s serverless service: until now it worked with ordinary processors, and now it can also use GPUs, an evolution not unlike the one that brought &lt;a href=&quot;/en/changelog/cloudflare-workers-containers&quot;&gt;containers alongside Cloudflare&apos;s Workers&lt;/a&gt; for heavier workloads.&lt;/p&gt;
&lt;h2&gt;Why it matters: the cost of an always-on GPU&lt;/h2&gt;
&lt;p&gt;The problem this announcement addresses is concrete, and it concerns anyone who wants to offer an AI-based feature: a chat, an image generator, a system that analyses text or photos, perhaps connected to external tools through standards like &lt;a href=&quot;/en/changelog/what-is-mcp&quot;&gt;MCP&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;The traditional way is to rent a machine with a GPU and keep it running. The catch is that you pay even while no request is coming in. A data-centre graphics card costs a fair bit per hour, and the traffic of almost any service isn&apos;t constant: there are peaks and there are dead hours, at night, on holidays. Keeping the &quot;engine&quot; running around the clock to serve requests concentrated in a few hours means paying mostly for the time the GPU sits idle, waiting.&lt;/p&gt;
&lt;p&gt;The alternative was to switch it off and on by hand, or to run your own system that adds and removes machines depending on load: doable, but it&apos;s work to maintain. The idea of serverless with GPUs is to take all of that off your plate: if there are no requests, nothing is running and you pay nothing.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Are you paying for a GPU that sits idle?&quot; text=&quot;We check your AI service&apos;s real traffic and work out whether serverless GPUs actually cut the bill in your case.&quot; button=&quot;Check your case →&quot;}&lt;/p&gt;
&lt;h2&gt;What Google announced&lt;/h2&gt;
&lt;p&gt;GPU support on Cloud Run has moved from preview to &lt;strong&gt;general availability&lt;/strong&gt;, meaning it&apos;s considered ready for production use and covered by the product&apos;s service commitments. The main points:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;The GPU on offer is the &lt;strong&gt;NVIDIA L4&lt;/strong&gt;, with &lt;strong&gt;24 GB of memory dedicated&lt;/strong&gt; to the card. It&apos;s a model designed for inference, not for training the largest models.&lt;/li&gt;
&lt;li&gt;The serverless principle holds: &lt;strong&gt;scale-to-zero&lt;/strong&gt;, so when no requests arrive the number of instances drops to zero and the GPU cost goes to zero too; and &lt;strong&gt;per-second billing&lt;/strong&gt;, you pay only for the GPU actually consumed.&lt;/li&gt;
&lt;li&gt;You no longer need to file a &lt;strong&gt;quota request&lt;/strong&gt;: the L4 GPU is available to every account, you just turn it on.&lt;/li&gt;
&lt;li&gt;Google states that an instance with the GPU and drivers already installed &lt;strong&gt;starts in about 5 seconds&lt;/strong&gt;. That&apos;s the time to make the card ready; on top of it you then add loading the model.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;To give a sense of the total time, Google cites an example with a small language model in which the first response arrives in about 19 seconds starting from zero instances: within those seconds are the startup, loading the model and generating the reply. It&apos;s a vendor example figure, tied to that specific model, not a guarantee that holds for every case.&lt;/p&gt;
&lt;h2&gt;How you use it, briefly&lt;/h2&gt;
&lt;p&gt;Anyone already familiar with Cloud Run finds the GPU as one more option. Turning it on via the console is a checkbox; from the command line it&apos;s a flag. Here&apos;s an example of deploying a model with the Ollama tool:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;gcloud run deploy my-service \
  --image ollama/ollama --port 11434 \
  --gpu 1 --cpu 4 --memory 16Gi
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;For the L4 GPU a minimum of &lt;strong&gt;4 CPUs and 16 GiB of memory&lt;/strong&gt; per instance is required. The service supports streaming the response over both HTTP and WebSocket: that means text can reach the user as it&apos;s being generated, as in chats, instead of appearing all at once at the end.&lt;/p&gt;
&lt;h2&gt;Where it&apos;s available and on what terms&lt;/h2&gt;
&lt;p&gt;At launch, GPUs on Cloud Run are active in &lt;strong&gt;five regions&lt;/strong&gt;: Iowa (United States), Belgium and the Netherlands (Europe), Singapore and Mumbai (Asia). Coverage is therefore still partial, as is normal for a feature that has just reached general availability; Google says more regions are on the way.&lt;/p&gt;
&lt;p&gt;By default, GPU instances are spread across several zones of the same region, to withstand the failure of a single zone. You can give up this redundancy to spend less, accepting a &quot;best-effort&quot; recovery - that is, not guaranteed - in the event of a zone problem.&lt;/p&gt;
&lt;p&gt;Beyond services that answer requests in real time, Google is also extending GPUs to &lt;strong&gt;Cloud Run jobs&lt;/strong&gt;, the batch tasks that start, do a piece of work and finish: fine-tuning a model on your own data, running inference over large amounts of images or text, transcoding video. At the time of the announcement this part is in private preview, so not yet open to everyone.&lt;/p&gt;
&lt;h2&gt;What to weigh before adopting it&lt;/h2&gt;
&lt;p&gt;Serverless with GPUs solves a specific problem, but it isn&apos;t the answer to everything. A few points to keep in mind.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Cold starts have a cost in time.&lt;/strong&gt; If the service has scaled to zero, the first request after a pause has to wait for the instance to power on and the model to load. For interactive use, a few seconds of initial wait can be annoying. Anyone who needs always-instant answers can keep one minimal instance always on, but then they partly give up the saving of scale-to-zero. It&apos;s a trade-off to tune to your own traffic.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;The L4 is an inference card.&lt;/strong&gt; It has 24 GB of memory: fine for small and mid-sized models and for serving requests. It isn&apos;t meant to train the largest models from scratch, which need different cards and far more memory.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Do the maths for your own case.&lt;/strong&gt; Serverless pays off when traffic is uneven, with peaks and long pauses. If instead the GPU is used almost continuously, a machine rented for a fixed time may cost less. The right question isn&apos;t &quot;how much does a second of GPU cost&quot;, but &quot;how many real hours a day would I actually use it&quot;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Mind the tie to the provider.&lt;/strong&gt; Packaging your service for Cloud Run is simple, but the way it scales, bills and is configured is specific to Google. Moving everything elsewhere later takes work. It&apos;s not a flaw, it&apos;s something to factor in, the same kind of trade-off worth weighing when you &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;compare cloud providers&lt;/a&gt; in general.&lt;/p&gt;
&lt;p&gt;In short, the underlying idea is reasonable and addresses a real cost: paying for a GPU only while it works, instead of keeping it running for nothing. For AI services with uneven traffic it can cut the cost noticeably and remove the chore of managing when machines turn on. For steady loads or very large models, traditional solutions remain a better fit. As always, the right choice is the one measured against your own case, not against the example figure in the press release.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to put an AI service into production without overpaying for infrastructure?&quot; text=&quot;We design and run AI backends on Google Cloud, from deploying on Cloud Run to cost monitoring, sizing the choice to your actual traffic.&quot; button=&quot;Cut your costs →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://cloud.google.com/blog/products/serverless/cloud-run-gpus-are-now-generally-available&quot;&gt;Cloud Run GPUs are now generally available (Google Cloud Blog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.cloud.google.com/run/docs/configuring/services/gpu&quot;&gt;GPU support for services (Cloud Run Documentation)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Gemini CLI: An Open Source AI Assistant in the Terminal</title><link>https://initd.it/en/changelog/gemini-cli</link><guid isPermaLink="true">https://initd.it/en/changelog/gemini-cli</guid><description>Google has released Gemini CLI, an open source AI agent that lives in the terminal. What it does, how the license works, the free limits, and the cautions for people who run servers and write code.</description><pubDate>Wed, 25 Jun 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;People who administer servers or write code spend much of the day in the terminal: the text window where you type commands to make the computer work. Many assistants based on artificial intelligence, by contrast, live in the browser or inside the editor. So there&apos;s a constant jump between the place where the work happens and the place where you ask for help. Gemini CLI, announced by Google on June 25, 2025, tries to remove that jump: it brings an AI assistant into the terminal, where the work actually happens.&lt;/p&gt;
&lt;h2&gt;What Gemini CLI is&lt;/h2&gt;
&lt;p&gt;Let&apos;s start with the terms. &lt;strong&gt;CLI&lt;/strong&gt; stands for &lt;em&gt;command-line interface&lt;/em&gt;: the way of using a program by typing text commands instead of clicking buttons. An &lt;strong&gt;AI agent&lt;/strong&gt; is a program that, beyond answering questions, can take concrete actions on your behalf: reading files, running commands, looking things up.&lt;/p&gt;
&lt;p&gt;Gemini CLI combines the two. You install it on your own computer, launch it from the terminal, and talk to it in plain language, the way you&apos;d write to a colleague. Behind the scenes it uses &lt;strong&gt;Gemini&lt;/strong&gt;, Google&apos;s family of AI models. At launch the assistant runs on Gemini 2.5 Pro, a model with a &lt;strong&gt;context window&lt;/strong&gt; of one million tokens, later joined by the next generation covered in &lt;a href=&quot;/en/changelog/gemini-3&quot;&gt;Gemini 3&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;That last point is worth explaining. A &lt;em&gt;token&lt;/em&gt; is a small chunk of text, roughly a syllable or a short word; the context window is how much text the model can keep in mind within a single conversation. One million tokens is a lot: it means you can hand the model entire projects, long log files, or extensive documentation without splitting them up by hand.&lt;/p&gt;
&lt;h2&gt;What it can do&lt;/h2&gt;
&lt;p&gt;The announcement and the documentation describe a general-purpose assistant, not one tied to a single task. The main things it can do:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Read and understand the code&lt;/strong&gt; of a project, explain it, and suggest changes.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Run commands&lt;/strong&gt; in the terminal and &lt;strong&gt;edit files&lt;/strong&gt;, always in the folder you&apos;re working in.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Search the web&lt;/strong&gt; through Google Search to ground its answers in current information, rather than only on the knowledge it was trained with.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Follow written instructions&lt;/strong&gt;: you can create a file called &lt;code&gt;GEMINI.md&lt;/code&gt; with rules and context specific to the project, so the assistant keeps them in mind, an idea close to that of &lt;a href=&quot;/en/changelog/agent-skills&quot;&gt;Agent Skills&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Two features deserve attention because they matter most to people working with servers.&lt;/p&gt;
&lt;p&gt;The first is support for &lt;a href=&quot;/en/changelog/what-is-mcp&quot;&gt;&lt;strong&gt;MCP&lt;/strong&gt;&lt;/a&gt;, short for &lt;em&gt;Model Context Protocol&lt;/em&gt;. It&apos;s an open standard, built to connect AI assistants to external tools and data sources in a uniform way. In practice MCP acts as a universal plug: it lets you give Gemini CLI the ability to talk to other systems (a database, an internal service, a company API) without reinventing the connection each time.&lt;/p&gt;
&lt;p&gt;The second is &lt;strong&gt;non-interactive use&lt;/strong&gt;. Beyond the conversational mode, the assistant can be called from within a script by passing it the request directly. That makes it a piece you can build into automation, not only a tool to use by hand.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# Run it without installing anything permanently
npx @google/gemini-cli

# Single request, no interface, suited to scripts
gemini -p &quot;Explain the architecture of this project&quot;

# JSON output, easier to process automatically
gemini -p &quot;List the defined services&quot; --output-format json
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Wondering whether a command-line agent fits your workflow?&quot; text=&quot;We assess where to place it, what data it can see, and what usage limits to set.&quot; button=&quot;Ask for an assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;Open source, with a caveat&lt;/h2&gt;
&lt;p&gt;The code for Gemini CLI is published on GitHub under the &lt;strong&gt;Apache 2.0 license&lt;/strong&gt;. It&apos;s a widely used permissive open source license: it lets you use, modify, and redistribute the program, including in commercial settings, with minimal obligations. In practice that means anyone can read the code to understand what it does, report problems, propose fixes, or adapt it to their own needs. For a tool that runs commands on your computer, being able to inspect the code is not a minor detail.&lt;/p&gt;
&lt;p&gt;An honest caveat is needed, though, because the phrase &quot;open source&quot; here covers one part only. What&apos;s open is the program you install locally, that is, the agent. The &lt;strong&gt;Gemini model&lt;/strong&gt;, on the other hand, remains a Google service running in its data centers: it isn&apos;t open source and can&apos;t be downloaded. Put differently, the requests and the context (the text, the code, the files you share) are sent to Google&apos;s servers to be processed. The computation happens in the cloud, not on your own computer.&lt;/p&gt;
&lt;h2&gt;What it costs and the usage limits&lt;/h2&gt;
&lt;p&gt;At launch Google offers free access tied to your personal Google account. The stated limits are 60 requests per minute and 1,000 requests per day, at no charge. The free package also includes a basic Gemini Code Assist license, the code-assistance service from the same family.&lt;/p&gt;
&lt;p&gt;For those who need more - a company, say, or heavy use - there are paid alternatives: you can use Google AI Studio or Vertex AI keys, with usage-based billing, or the Gemini Code Assist Standard and Enterprise licenses. The free version is enough to try it out and for personal use; past a certain threshold you move to a paid plan.&lt;/p&gt;
&lt;h2&gt;Why it matters to admins and developers&lt;/h2&gt;
&lt;p&gt;The value isn&apos;t in the novelty itself, but in where the tool sits. People who run systems already have the terminal open: having an assistant right there avoids switching context. Some practical uses that come up in day-to-day work:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Getting an error message or a chunk of a log file explained without pasting it somewhere else.&lt;/li&gt;
&lt;li&gt;Getting a draft command or configuration to review, instead of writing it from scratch.&lt;/li&gt;
&lt;li&gt;Quickly making sense of a project inherited from someone else, by asking for a description of its structure.&lt;/li&gt;
&lt;li&gt;Building a request to the assistant into a script, using the non-interactive mode.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Being open source and based on an open standard like MCP also reduces the risk of being locked into a single vendor for the client side: the program can be read, adapted, and, in principle, connected to other tools.&lt;/p&gt;
&lt;h2&gt;Limits and cautions&lt;/h2&gt;
&lt;p&gt;Before adopting it, a few points are worth keeping in mind, without hype.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;It&apos;s in preview.&lt;/strong&gt; Google describes it as a preview release: it may contain bugs, changing behavior, and features that aren&apos;t yet stable. It&apos;s not the thing to build critical processes on without a fallback.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Data leaves your computer.&lt;/strong&gt; Because the model runs in the cloud, whatever you share with the assistant is sent to Google. For confidential content - proprietary code, credentials, customer data - that&apos;s something to weigh carefully and to govern by your own policies, also in light of what &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR requires on the infrastructure side&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;It runs commands and edits files.&lt;/strong&gt; That&apos;s its strength, but also its risk. An agent that can launch commands needs supervision: it&apos;s wise to review what it proposes before authorizing it, especially on production systems.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;It can be wrong.&lt;/strong&gt; Like any model of this kind, it sometimes produces incorrect or made-up answers. Treat the output as a draft to verify, not as truth to apply as-is.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Gemini CLI is an AI agent that lives in the terminal: it reads code, runs commands, searches the web, and can be called from within scripts. The program is open source under the Apache 2.0 license, while the Gemini model that powers it remains a service in Google&apos;s cloud. There&apos;s a free plan with generous limits and paid options for heavier use. It&apos;s useful because it puts the assistant where admins and developers already work, but it should be used with judgment: it&apos;s in preview, it sends data to the cloud, and it can take actions on the system. One more tool, to be kept under control, not an autopilot.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to automate sysadmin tasks with an AI agent, safely?&quot; text=&quot;We integrate tools like Gemini CLI into the workflows of the servers we manage, defining what it can run and which data it should never see.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.google/innovation-and-ai/technology/developers-tools/introducing-gemini-cli-open-source-ai-agent/&quot;&gt;Introducing Gemini CLI: your open-source AI agent - The Keyword, Google&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/google-gemini/gemini-cli&quot;&gt;google-gemini/gemini-cli - GitHub&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Cloudflare brings containers alongside Workers (public beta)</title><link>https://initd.it/en/changelog/cloudflare-workers-containers</link><guid isPermaLink="true">https://initd.it/en/changelog/cloudflare-workers-containers</guid><description>Cloudflare has opened the public beta of Containers: you can run containerised workloads next to Workers, orchestrated from your code, without managing clusters and regions. Here&apos;s what it is, what it&apos;s for, and where it stands.</description><pubDate>Wed, 25 Jun 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone who builds web applications knows two worlds that, until now, have been awkward to keep together. On one side there are &quot;serverless&quot; functions: small, lightweight programs that start instantly and handle plenty of traffic, but with little memory and tight execution times. On the other there are the &quot;real&quot; applications, the ones that need a full environment - an operating system, system libraries, a specific runtime - and that are usually packaged into a &lt;em&gt;container&lt;/em&gt;. On 24 June 2025, Cloudflare, one of the world&apos;s largest network and CDN operators, opened the &lt;strong&gt;public beta&lt;/strong&gt; of a service that tries to bring these two worlds closer: Containers, which run alongside Workers and are driven by the same code.&lt;/p&gt;
&lt;h2&gt;First, a refresher: Workers and containers&lt;/h2&gt;
&lt;p&gt;It&apos;s worth being clear about the two terms, because that&apos;s where the news lives.&lt;/p&gt;
&lt;p&gt;A &lt;strong&gt;Worker&lt;/strong&gt; is a small program that runs on Cloudflare&apos;s servers spread around the world. It&apos;s &quot;serverless&quot;: there&apos;s no server to administer, the code runs close to whoever makes the request, it starts in a fraction of a second, and it scales effortlessly. In return it&apos;s deliberately limited: little memory, little CPU time, a narrow environment built for JavaScript or WebAssembly. Perfect for routing requests, applying rules, composing responses; poorly suited to heavy, sustained work.&lt;/p&gt;
&lt;p&gt;A &lt;strong&gt;container&lt;/strong&gt;, on the other hand, is a way of packaging an application together with everything it needs to run: its runtime, its libraries, its system files. The upside is that it runs the same everywhere, regardless of the underlying machine. It&apos;s the format most software ships in today, from backends to command-line tools.&lt;/p&gt;
&lt;p&gt;The historical limitation was that Workers, on their own, couldn&apos;t host a container: that required a separate piece of infrastructure, with its own complexity. That&apos;s exactly what changes here: the two now live on the same platform.&lt;/p&gt;
&lt;h2&gt;What Cloudflare announced&lt;/h2&gt;
&lt;p&gt;In short: you can now &lt;strong&gt;run containers alongside Workers&lt;/strong&gt;, on Cloudflare&apos;s global network, without having to deal with orchestrators, clusters, or regions. The service is available in public beta for anyone on a paid plan.&lt;/p&gt;
&lt;p&gt;Cloudflare frames the core idea neatly: use a Worker when you need to be lightweight and scalable; use a container when you need more power and freedom. The two aren&apos;t competitors, they work together. The Worker stays the front door - it receives the request and decides what to do with it - and when there&apos;s a demanding job to run, it hands it off to a container.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Got a workload too heavy for serverless but not worth a whole cluster?&quot; text=&quot;We assess whether a Worker, a container, or a dedicated VM fits your case best, without over-provisioning your infrastructure.&quot; button=&quot;Assess your case →&quot;}&lt;/p&gt;
&lt;h2&gt;How Workers and containers fit together&lt;/h2&gt;
&lt;p&gt;The interesting part is that you don&apos;t manage the container from a separate panel: you drive it from the Worker&apos;s code. A container is described in the project&apos;s configuration file (&lt;code&gt;wrangler.jsonc&lt;/code&gt;) by pointing at the image to use, and from there the Worker can start it, reach it, and shut it down.&lt;/p&gt;
&lt;p&gt;Under the hood the architecture builds on &lt;strong&gt;Durable Objects&lt;/strong&gt;, another Cloudflare building block used to coordinate state and instances in an orderly way. The mechanism is easy to grasp: each distinct identifier passed to a container maps to its own isolated, dedicated instance. Need one container per user, or per job? Just use a different identifier and the platform spins up a separate one. Cloudflare chooses where on the network to start the instances, with startup times on the order of a few seconds.&lt;/p&gt;
&lt;p&gt;The workflow is meant to be short too. Locally you develop with &lt;code&gt;wrangler dev&lt;/code&gt;, which builds the container image automatically; to publish you run &lt;code&gt;wrangler deploy&lt;/code&gt;, with no need to manage a separate image registry by hand.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// wrangler.jsonc, simplified
{
  &quot;containers&quot;: [
    {
      &quot;class_name&quot;: &quot;MyContainer&quot;,
      &quot;image&quot;: &quot;./Dockerfile&quot;,
      &quot;instance_type&quot;: &quot;basic&quot;
    }
  ]
}
&lt;/code&gt;&lt;/pre&gt;
&lt;h2&gt;What it&apos;s for&lt;/h2&gt;
&lt;p&gt;The typical uses are the ones where a Worker alone isn&apos;t enough and, until now, you&apos;d have had to stand up a dedicated server:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Command-line tools and &quot;batch&quot; jobs.&lt;/strong&gt; Existing programs, perhaps written in any language, that process something and return a result.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Media and data processing.&lt;/strong&gt; Converting a video or an image, transforming files, running pipelines that need CPU, memory, and a real disk: tasks that would blow past a Worker&apos;s limits, not unlike what happens when an application needs a &lt;a href=&quot;/en/changelog/cloud-run-gpu&quot;&gt;GPU for AI inference&lt;/a&gt; and a lightweight function no longer cuts it.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Backends in any language.&lt;/strong&gt; An application already packaged as a container can run as-is, with a Worker in front acting as a router.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Isolated environments for untrusted code.&lt;/strong&gt; Giving each user a separate container, for example to run code generated or submitted by third parties without letting them interfere with one another. It&apos;s a scenario mentioned for AI agents and the &lt;a href=&quot;/en/changelog/what-is-mcp&quot;&gt;MCP servers&lt;/a&gt; they connect to as well, which often need an isolated space to operate in.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;Why it lowers the barrier&lt;/h2&gt;
&lt;p&gt;This is the practical point. Running containers in many parts of the world today usually means dealing with a fair amount of infrastructure, the same kind usually described and versioned with &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;Infrastructure as Code&lt;/a&gt; tools: choosing regions, standing up an orchestrator (often Kubernetes), configuring load balancing, handling scaling and updates. That&apos;s work that takes specific skills and constant maintenance time.&lt;/p&gt;
&lt;p&gt;The proposed approach shifts that weight onto the platform. You don&apos;t pick regions: the network decides where to run. You don&apos;t configure a cluster: you declare a container and drive it from code. For a workload that doesn&apos;t fit inside a serverless function today but doesn&apos;t justify running a whole cluster either, this is a way to sit in the middle with less friction.&lt;/p&gt;
&lt;p&gt;To be honest about it, &quot;less infrastructure to manage&quot; also means less fine-grained control and a tighter tie to a single platform, the same trade-off worth weighing when you &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;choose a cloud provider&lt;/a&gt;. It&apos;s a trade-off, not a free lunch: it&apos;s worth weighing case by case.&lt;/p&gt;
&lt;h2&gt;How you pay, and what the limits are&lt;/h2&gt;
&lt;p&gt;The cost model is usage-based and fine-grained: you pay only while the container is actually running, measured in very short intervals (on the order of 10 milliseconds), with CPU, memory, and disk metered separately. After a period of inactivity the container puts itself to sleep, so you don&apos;t pay for idle time. The paid plan includes a monthly allowance; the exact figures are on the pricing page.&lt;/p&gt;
&lt;p&gt;At launch there are three instance sizes - roughly from 256 MiB up to a few GiB of memory, with growing CPU and disk quotas - and, this being a beta, there are account-wide caps. These are limits meant for the trial phase and set to grow: Cloudflare has listed larger instances, higher numbers, and automatic, latency-aware scaling among the future work, along with tighter integration with the platform&apos;s other services (storage, databases, key-value).&lt;/p&gt;
&lt;h2&gt;Where it stands&lt;/h2&gt;
&lt;p&gt;The usual caution applies. This is a &lt;strong&gt;public beta&lt;/strong&gt;: open to anyone on a paid plan, but still a trial phase, with tight limits and features still evolving. Some things you&apos;d expect from a mature platform - automatic scaling, larger instances, certain integrations - are stated as coming, not as already here.&lt;/p&gt;
&lt;p&gt;The underlying idea, though, is concrete and already testable: bring containers to where Workers already run, and drive them with the same code, instead of keeping two separate infrastructures. For anyone who struggles today to fit heavy workloads into a serverless environment, it&apos;s worth trying on a small project - bearing in mind it&apos;s still a beta and that the bill is worth watching closely while you experiment.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to run a containerised workload in production without managing a cluster?&quot; text=&quot;We design and run custom cloud infrastructure, from Workers to containers to traditional servers, picking the right tool for each piece.&quot; button=&quot;Let&apos;s talk about your project →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.cloudflare.com/containers-are-available-in-public-beta-for-simple-global-and-programmable/&quot;&gt;Containers are available in public beta for simple, global, and programmable compute (Cloudflare Blog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developers.cloudflare.com/containers/&quot;&gt;Cloudflare Containers - Overview (Cloudflare Docs)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.cloudflare.com/cloudflare-containers-coming-2025/&quot;&gt;Simple, scalable, and global: Containers are coming to Cloudflare Workers in 2025 (Cloudflare Blog)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>What a VPN Is and How WireGuard Works</title><link>https://initd.it/en/changelog/wireguard-vpn</link><guid isPermaLink="true">https://initd.it/en/changelog/wireguard-vpn</guid><description>What a VPN is in plain terms, what it&apos;s for, and why WireGuard has become popular: simplicity, performance, and modern cryptography compared to older solutions.</description><pubDate>Thu, 12 Jun 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;You hear the word VPN in very different contexts. People working from home use it to connect to office systems, people running servers use it to let those servers talk to each other securely, and some install it on their phone to feel safer on a public Wi-Fi network. Behind such different uses lies the same basic idea. And in recent years, among the many ways to build a VPN, one in particular has stood out for its simplicity: WireGuard. It&apos;s worth understanding what a VPN is and why WireGuard has become a reference point.&lt;/p&gt;
&lt;h2&gt;What a VPN is, in plain terms&lt;/h2&gt;
&lt;p&gt;VPN stands for &lt;em&gt;Virtual Private Network&lt;/em&gt;. Put without jargon, it&apos;s an &lt;strong&gt;encrypted tunnel between two points&lt;/strong&gt; running over a public network like the Internet. Wikipedia&apos;s documentation describes it as a network that &quot;extends a private network across a public network&quot; using encryption and tunneling protocols.&lt;/p&gt;
&lt;p&gt;An analogy helps. The Internet is like a crowded room where many messages travel from one side to another, and in principle anyone in the middle can watch them pass. A VPN is like running those messages through a sealed tube: someone watching from outside can tell that something is going through, but can&apos;t read its content. The two key words are exactly these. &lt;strong&gt;Encryption&lt;/strong&gt;: the data is transformed so that only the two ends of the tunnel can decrypt it. &lt;strong&gt;Tunnel&lt;/strong&gt;: the traffic is encapsulated, wrapped in a shell that carries it from one point to the other as if the two ends were on the same local network, even though they&apos;re actually far apart.&lt;/p&gt;
&lt;h2&gt;What it&apos;s for&lt;/h2&gt;
&lt;p&gt;The concrete uses of a VPN fall into three families, which Wikipedia lists as typical cases.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Remote access.&lt;/strong&gt; It lets someone off-site reach the office network securely over the Internet. This is the work-from-home case: you access files, internal applications, and company tools as if you were physically on-site. It is also the right way to administer network devices remotely, instead of leaving the management interface open on the Internet: the &lt;a href=&quot;/en/changelog/mikrotik-routeros-ssh-vulnerabilities&quot;&gt;MikroTik RouterOS SSH flaws&lt;/a&gt; showed what happens otherwise.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Site-to-site connectivity.&lt;/strong&gt; It joins two separate networks, for example an office and a datacenter, or two servers in different locations that need to exchange data without exposing themselves on the Internet. This is the most common scenario when talking about &lt;a href=&quot;/en/changelog/terraform-getting-started&quot;&gt;infrastructure&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Connection privacy.&lt;/strong&gt; Many commercial services use a VPN to encrypt a user&apos;s traffic and reduce the risk of interception, typically on untrusted networks. It&apos;s worth saying plainly that here the trust shifts to the VPN provider, who still sees the traffic pass through.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The common thread is always the same: connecting two points securely, without having to trust the network in between.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Are your servers still talking to each other directly exposed on the Internet?&quot; text=&quot;We can check how your machines are connected and whether a VPN tunnel would shrink the exposed surface.&quot; button=&quot;Check your network →&quot;}&lt;/p&gt;
&lt;h2&gt;What WireGuard is&lt;/h2&gt;
&lt;p&gt;Building a VPN requires a &lt;em&gt;protocol&lt;/em&gt;, a set of rules that define how the two ends recognize each other, how they encrypt data, and how they route it. For years the most common tools were OpenVPN and IPsec, both solid but also heavy to configure. WireGuard is a more recent project, created by Jason A. Donenfeld, and it comes with a stated goal: to do the same things in a much simpler way.&lt;/p&gt;
&lt;p&gt;Its own official page describes it as &quot;an extremely simple yet fast and modern VPN that utilizes state-of-the-art cryptography.&quot; Under the hood, WireGuard encapsulates IP packets inside &lt;strong&gt;UDP&lt;/strong&gt;, one of the Internet&apos;s basic transport protocols. In practical terms, it became part of the Linux kernel with version 5.6, released on 29 March 2020, and it&apos;s also available on Windows, macOS, Android, iOS, and the BSD systems. One detail captures its philosophy well: the documentation says it aims to be &quot;as easy to configure and deploy as SSH.&quot; Once decrypted, the packets leaving the tunnel are ordinary IP packets that the server&apos;s firewall sees in the clear: that is why &lt;a href=&quot;/en/changelog/cve-2026-98432-firewall-workaround-nftables&quot;&gt;the nftables rule against CVE-2026-98432&lt;/a&gt; loaded on the server also filters the traffic coming from the clients connected over the VPN.&lt;/p&gt;
&lt;h2&gt;Why it has become popular&lt;/h2&gt;
&lt;p&gt;WireGuard&apos;s success isn&apos;t down to a single flashy feature, but to three underlying choices that, taken together, change the experience of using it.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Simplicity.&lt;/strong&gt; OpenVPN and IPsec are huge projects, with codebases that are hard to review thoroughly even for teams of experts. WireGuard starts from the opposite idea: few lines of code, meant to be &quot;comprehensively reviewable by single individuals.&quot; Less code means less surface where mistakes can hide and fewer things to configure by hand.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Performance.&lt;/strong&gt; On Linux systems, WireGuard lives inside the kernel, the core of the operating system, instead of running as a separate program. This avoids constant switching between the two worlds and translates into higher speed, lower latency, and less work for the processor. The official page calls it &quot;considerably more performant than OpenVPN.&quot;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Modern cryptography.&lt;/strong&gt; WireGuard doesn&apos;t let you pick among dozens of algorithms, as older protocols do. It uses a fixed, up-to-date set based on the &lt;em&gt;Noise protocol framework&lt;/em&gt; and primitives like Curve25519, ChaCha20, Poly1305, and BLAKE2. The advantage is subtle but important: where there&apos;s no negotiation over which algorithm to use, there&apos;s also no risk of an attacker forcing it toward a weak choice.&lt;/p&gt;
&lt;h2&gt;The heart of WireGuard: keys and cryptokey routing&lt;/h2&gt;
&lt;p&gt;This is the most interesting difference from many traditional systems. WireGuard doesn&apos;t use usernames and passwords, the same key-pair approach behind the cryptographic signatures in &lt;a href=&quot;/en/changelog/web-bot-auth&quot;&gt;Web Bot Auth&lt;/a&gt;. Each node on the network has a &lt;strong&gt;key pair&lt;/strong&gt;: a private key, which stays on the machine and never leaves it, and a public key, which is shared with the others. The mechanism is the same as &lt;a href=&quot;/en/changelog/bastion-host&quot;&gt;SSH keys&lt;/a&gt;: whoever holds my public key can encrypt traffic toward me and verify that it&apos;s really me replying, but can&apos;t impersonate me.&lt;/p&gt;
&lt;p&gt;Each party, in WireGuard&apos;s terms, is called a &lt;em&gt;peer&lt;/em&gt;: there&apos;s no rigid hierarchy between client and server, just nodes that talk to each other. The glue that holds it all together is what the official documentation calls &lt;strong&gt;cryptokey routing&lt;/strong&gt;: each public key is associated with a list of IP addresses allowed inside the tunnel. This list does two jobs in one. Outbound, it behaves like a routing table: it decides which peer, and with which key, a packet should be encrypted for. Inbound, it behaves like an access control list: it accepts a packet only if it comes from the right peer and from an address that belongs to it.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[Peer]
PublicKey = &amp;lt;the-other-node-public-key&amp;gt;
AllowedIPs = 10.0.0.2/32
Endpoint = other-node.example.net:51820
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;A few lines say it all: who the other node is (its key), which addresses belong to it, and where to reach it. This link between key and address brings another convenience, &lt;em&gt;roaming&lt;/em&gt;: since a peer is identified by its key and not its network address, if it changes connection - say a laptop switching from Wi-Fi to mobile data - the tunnel doesn&apos;t break. WireGuard discovers the new address simply from where the correctly encrypted data arrives.&lt;/p&gt;
&lt;h2&gt;WireGuard compared to OpenVPN and IPsec&lt;/h2&gt;
&lt;p&gt;The official page doesn&apos;t dance around it: WireGuard aims to be &quot;faster, simpler, leaner, and more useful than IPsec.&quot; The same idea holds against OpenVPN, with the added benefit of a much smaller codebase that&apos;s therefore easier to review.&lt;/p&gt;
&lt;p&gt;This doesn&apos;t mean the older solutions should be thrown away. IPsec is still the most widespread standard for getting network devices from different vendors to talk to each other, and OpenVPN can cross hostile firewalls by passing itself off as ordinary web traffic. They&apos;re mature tools with years of experience behind them. WireGuard&apos;s point is a different one: for the common case of securely connecting systems you control, it delivers the same result with less code, less configuration, and fewer ways to get it wrong.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;A VPN is an encrypted tunnel between two points running over the Internet, and it exists to connect them securely: remote access, site-to-site links, or connection protection. WireGuard is a recent way to build one, popular because it combines three things that are hard to have all at once: simplicity, performance, and modern cryptography. Instead of passwords it uses key pairs like SSH, and it ties each key to the addresses allowed in the tunnel. It doesn&apos;t make IPsec and OpenVPN obsolete, but for many scenarios it&apos;s now the most direct path.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Need to connect offices, servers and remote sites securely?&quot; text=&quot;We design and manage WireGuard VPNs for remote access and site-to-site links, from key generation to peer configuration.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.wireguard.com/&quot;&gt;WireGuard: fast, modern, secure VPN tunnel - official site&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.wireguard.com/protocol/&quot;&gt;WireGuard - Protocol &amp;amp; Cryptography&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://en.wikipedia.org/wiki/Virtual_private_network&quot;&gt;Virtual private network - Wikipedia&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://en.wikipedia.org/wiki/WireGuard&quot;&gt;WireGuard - Wikipedia (kernel 5.6, platforms, author)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Amazon Aurora DSQL: a distributed, always-on SQL database</title><link>https://initd.it/en/changelog/aws-aurora-dsql</link><guid isPermaLink="true">https://initd.it/en/changelog/aws-aurora-dsql</guid><description>Amazon Aurora DSQL is now generally available: a serverless, distributed SQL database with multi-Region high availability and strong consistency. What it is and when it fits.</description><pubDate>Wed, 28 May 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Keeping a database reachable at all times is one of the hardest problems for anyone running online services. A database is the ledger where an application keeps its data: orders, users, payments, catalogue. If it stops, everything stops. And when that same data has to be read and updated from different parts of the world at once, keeping it coherent becomes a puzzle. On 27 May 2025 AWS made Amazon Aurora DSQL generally available - meaning it left the restricted preview phase and opened to everyone - a database built for exactly this scenario.&lt;/p&gt;
&lt;h2&gt;What Aurora DSQL is&lt;/h2&gt;
&lt;p&gt;Aurora DSQL is a relational database: it organises data into tables of rows and columns that you query with SQL, the language used for this kind of store for decades. Two traits set it apart from a database installed on a traditional server.&lt;/p&gt;
&lt;p&gt;It&apos;s &lt;strong&gt;serverless&lt;/strong&gt;. &quot;Serverless&quot; doesn&apos;t mean there are no servers; it means the people using the service don&apos;t have to choose, size, start or update them: AWS handles that behind the scenes. Developers just see an endpoint to connect to, and pay for the work the database actually does.&lt;/p&gt;
&lt;p&gt;It&apos;s &lt;strong&gt;distributed&lt;/strong&gt;. The data doesn&apos;t live on a single machine. It&apos;s replicated automatically across several availability zones (nearby but independent data centres within a Region) and, if you want, across multiple geographic Regions.&lt;/p&gt;
&lt;p&gt;A third detail matters to anyone already working with these tools: Aurora DSQL is &lt;strong&gt;PostgreSQL-compatible&lt;/strong&gt;, PostgreSQL being one of the most widely used open source databases. The AWS documentation states compatibility with PostgreSQL version 16. In practice you connect with the same drivers, libraries and tools you already use with PostgreSQL, such as the &lt;code&gt;psql&lt;/code&gt; client.&lt;/p&gt;
&lt;h2&gt;The problem it sets out to solve&lt;/h2&gt;
&lt;p&gt;Anyone who runs a traditional database knows the list of headaches by heart.&lt;/p&gt;
&lt;p&gt;The first is &lt;strong&gt;maintenance&lt;/strong&gt;. Applying security updates (patches) or moving to a new version often needs a window in which the database is slowed down or stopped. It has to be planned, announced and watched over.&lt;/p&gt;
&lt;p&gt;The second is &lt;strong&gt;failover&lt;/strong&gt;: what happens when the primary machine fails. In a classic setup a standby copy is ready to take over, but the switch has to be managed and is never entirely painless - there&apos;s a stretch where the service struggles, downtime that has to stay under &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;how long you can afford to be down&lt;/a&gt;, and in the worst cases you risk losing the most recent writes.&lt;/p&gt;
&lt;p&gt;The third is &lt;strong&gt;growth&lt;/strong&gt;. When data or traffic outgrows a single machine, the classic route is &lt;em&gt;sharding&lt;/em&gt;: splitting the data into many pieces (shards) spread across several machines. It works, but it complicates everything. The application has to know which shard holds each record, and operations spanning more than one shard become slow and brittle.&lt;/p&gt;
&lt;p&gt;Aurora DSQL is built to lift these three chores off developers&apos; shoulders: no manual patching, no failover to orchestrate, no sharding to design by hand.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Is your application still handling failover and sharding by hand?&quot; text=&quot;We review your current data architecture and check whether a managed, distributed database would actually cut the operational load.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;High availability and strong consistency&lt;/h2&gt;
&lt;p&gt;These are two different promises, and it&apos;s worth keeping them apart.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Availability&lt;/strong&gt; measures how much of the time the service stays reachable. It&apos;s usually expressed as a percentage. For Aurora DSQL, AWS states &lt;strong&gt;99.99% availability in a single Region&lt;/strong&gt; and &lt;strong&gt;99.999% across multiple Regions&lt;/strong&gt;. Put into concrete time: 99.99% means allowing at most roughly 52 minutes of downtime a year; 99.999% drops that to a little over 5 minutes a year. These are targets the provider states, not guarantees that nothing can ever go wrong, but they give a sense of the order of magnitude.&lt;/p&gt;
&lt;p&gt;How does it get there? With an architecture AWS describes as &lt;strong&gt;active-active&lt;/strong&gt;. Instead of one primary copy doing the work and a standby waiting, several copies work at the same time and can accept both reads and writes. If a component fails, traffic is rerouted automatically to healthy ones, without the traditional failover to coordinate. Each component is made redundant across three availability zones.&lt;/p&gt;
&lt;p&gt;In the &lt;strong&gt;multi-Region&lt;/strong&gt; setup, two clusters in two different Regions present themselves to the application as a single logical database: both endpoints accept reads and writes, a setup that also touches on &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR compliance&lt;/a&gt; once data crosses several geographic areas. Acting as a referee is a third Region with a reduced role, called a &lt;em&gt;log-only witness&lt;/em&gt; - it doesn&apos;t serve requests but helps decide which version of the data is correct if something goes wrong.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Strong consistency&lt;/strong&gt; is the second promise, and the more delicate one. In a distributed system, after a write the various copies of a record can take a moment to line up. Many systems accept this lag: it&apos;s called &lt;em&gt;eventual consistency&lt;/em&gt;, meaning &quot;sooner or later all copies will match&quot;. In the meantime, though, two users might read different values. Strong consistency instead promises that every read always sees the latest write, even one made from another Region. For a shopping cart, a balance or a booking, that distinction isn&apos;t a detail: it&apos;s the difference between selling the last item in stock twice or not. Aurora DSQL provides ACID transactions (the properties that make database operations reliable) with strong consistency, including across Regions.&lt;/p&gt;
&lt;h2&gt;Serverless: scaling without sharding or patching&lt;/h2&gt;
&lt;p&gt;The serverless side turns into two practical conveniences.&lt;/p&gt;
&lt;p&gt;The first is &lt;strong&gt;automatic scaling&lt;/strong&gt;. Aurora DSQL adjusts &lt;a href=&quot;/en/changelog/aws-graviton5&quot;&gt;compute&lt;/a&gt;, read/write throughput and storage on its own, based on the load. If traffic doubles there&apos;s no server to enlarge by hand and no sharding to redesign: this is usually the most time-consuming task, and here, on paper, it disappears.&lt;/p&gt;
&lt;p&gt;The second is &lt;strong&gt;no maintenance on the user&apos;s side&lt;/strong&gt;. There are no servers to update, so there are no patching or upgrade windows to schedule, and none of the downtime that usually comes with them.&lt;/p&gt;
&lt;h2&gt;PostgreSQL-compatible, but with limits&lt;/h2&gt;
&lt;p&gt;Some honesty is needed here, because &quot;compatible&quot; doesn&apos;t mean &quot;identical&quot;. Aurora DSQL speaks the PostgreSQL protocol and supports a broad slice of its features, but not all of them: AWS keeps a documentation page dedicated to what is and isn&apos;t supported. Before assuming an existing PostgreSQL application will run unchanged, it&apos;s worth checking that list.&lt;/p&gt;
&lt;p&gt;There are also constraints on multi-Region use. At launch, multi-Region clusters could only be created among Regions in the same geographic grouping, and combinations across different continents weren&apos;t supported. That&apos;s a limit to factor in if the goal is serving users scattered across several continents from a single cluster.&lt;/p&gt;
&lt;h2&gt;Where it fits&lt;/h2&gt;
&lt;p&gt;Aurora DSQL is optimised for &lt;strong&gt;transactional&lt;/strong&gt; workloads: many small, frequent operations - placing an order, updating a balance, recording a payment - where reliability and coherence are what count. AWS positions it for microservice, serverless and event-driven architectures, and mentions areas such as banking, ecommerce, travel, retail, multi-tenant SaaS, payments and gaming.&lt;/p&gt;
&lt;p&gt;The opposite reasoning matters too, so as not to use it where it doesn&apos;t help. It isn&apos;t meant as a tool for analysing large volumes of historical data (so-called analytical or OLAP workloads), which follow different logic. And if an application needs a specific PostgreSQL feature that isn&apos;t supported yet, or if a plain managed database in a single Region already covers the need, the complexity of a distributed database can be more than the job requires. The right choice depends on concrete availability and geographic-distribution requirements, not on the novelty itself.&lt;/p&gt;
&lt;h2&gt;Pricing, in brief&lt;/h2&gt;
&lt;p&gt;The cost model is pay-as-you-go. You pay for the work done through units called DPUs (Distributed Processing Units), which measure reads and writes, plus storage billed by GB-month. AWS includes a monthly free tier: the first 100,000 DPUs and 1 GB-month of storage each month are free. For real figures it&apos;s best to start from the official pricing page anyway, because the total depends heavily on how the database is used, much like when you &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;compare offers from different cloud providers&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Considering a distributed database for your application?&quot; text=&quot;We design and manage cloud infrastructure on AWS and Google Cloud, from choosing the right database to migration, keeping an eye on cost and uptime.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://aws.amazon.com/blogs/aws/amazon-aurora-dsql-is-now-generally-available/&quot;&gt;Amazon Aurora DSQL is now generally available (AWS News Blog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.aws.amazon.com/aurora-dsql/latest/userguide/what-is-aurora-dsql.html&quot;&gt;What is Amazon Aurora DSQL? (AWS Documentation)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Web Bot Auth: identifying bots with cryptographic signatures</title><link>https://initd.it/en/changelog/web-bot-auth</link><guid isPermaLink="true">https://initd.it/en/changelog/web-bot-auth</guid><description>Cloudflare proposes Web Bot Auth: legitimate bots and AI agents sign their HTTP requests with a cryptographic signature (RFC 9421), instead of being recognised by spoofable IPs or User-Agents.</description><pubDate>Thu, 22 May 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone running a website gets a lot of daily visits that don&apos;t come from people, but from automated programs. Some are useful - a search engine crawler, a feed aggregator, an uptime monitor - and some aren&apos;t, like the ones that copy content or probe for holes. On top of these there are now &lt;a href=&quot;/en/changelog/agent-skills&quot;&gt;AI agents&lt;/a&gt;: assistants that browse the web on a user&apos;s behalf to answer a question or carry out a task. The problem is old but increasingly pressing: how do you tell a legitimate bot from one that&apos;s only pretending to be?&lt;/p&gt;
&lt;p&gt;In mid-May 2025 Cloudflare, one of the world&apos;s largest network and CDN operators, put forward a proposal to answer that question. It&apos;s called &lt;strong&gt;Web Bot Auth&lt;/strong&gt;. The core idea is simple. Instead of guessing who&apos;s behind a request from clues that are easy to fake, you ask the bot to &lt;em&gt;sign&lt;/em&gt; its requests with a verifiable cryptographic signature.&lt;/p&gt;
&lt;h2&gt;The problem: recognising bots today is fragile&lt;/h2&gt;
&lt;p&gt;A &quot;bot&quot; is simply a program that sends web requests without a person clicking in real time. Today, anyone trying to work out whether a bot is trustworthy has only weak tools to lean on.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;The User-Agent.&lt;/strong&gt; This is a line of text every request carries to declare &quot;who I am&quot; (for example the name of the browser or crawler). The trouble is that it&apos;s free text: anyone can write whatever they like in it. Impersonating a search engine crawler is trivial.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;IP address ranges.&lt;/strong&gt; The IP address is the &quot;phone number&quot; a request comes from. Some operators publish the ranges their bots use, so sites can build &lt;em&gt;allowlists&lt;/em&gt; (lists of permitted addresses). But it&apos;s a brittle mechanism: IPs change, they&apos;re often shared between different services, and many tools go through proxies or VPNs that hide their origin. Keeping those lists up to date is constant, imperfect work.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Secret tokens.&lt;/strong&gt; You could hand each bot a password to present to the site. That doesn&apos;t scale: it would need a separate credential for every site to visit, and a prior agreement with each one.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The upshot is that, today, &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;blocking bad bots&lt;/a&gt; without hitting the good ones is an exercise in approximation.&lt;/p&gt;
&lt;h2&gt;What Web Bot Auth is&lt;/h2&gt;
&lt;p&gt;Web Bot Auth flips the approach: rather than guessing a bot&apos;s identity, it asks the bot to prove it with cryptography.&lt;/p&gt;
&lt;p&gt;A quick reminder of what a digital signature is. Whoever signs holds two linked keys: a &lt;strong&gt;private&lt;/strong&gt; one, kept secret, and a &lt;strong&gt;public&lt;/strong&gt; one, shared with everyone. The private key &quot;seals&quot; a message; the public key lets anyone verify that the seal is authentic and that the message hasn&apos;t been altered. The important part is that only the holder of the private key can produce a valid signature: you can&apos;t forge one by looking at the public key, the same key-pair principle that lets &lt;a href=&quot;/en/changelog/wireguard-vpn&quot;&gt;WireGuard&lt;/a&gt; do away with passwords.&lt;/p&gt;
&lt;p&gt;Web Bot Auth applies this principle to HTTP requests. A legitimate bot generates a key pair, publishes the public one at a known location, and signs every request with the private one. The receiving site fetches the public key and verifies the signature. If it checks out, the site knows for certain which operator the request came from.&lt;/p&gt;
&lt;p&gt;Underneath sits a standard already published by the IETF (the body that maintains Internet&apos;s technical standards): &lt;strong&gt;RFC 9421, HTTP Message Signatures&lt;/strong&gt;, from February 2024. It defines, in general terms, how to sign parts of an HTTP message and how to attach the signature through two headers, &lt;code&gt;Signature-Input&lt;/code&gt; and &lt;code&gt;Signature&lt;/code&gt;. Web Bot Auth reinvents nothing: it&apos;s a specific way of using that standard for the bot case.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do you actually know who&apos;s behind the requests hitting your site every day?&quot; text=&quot;We can analyze your bot and AI traffic and check what you can already filter reliably.&quot; button=&quot;Analyze your traffic →&quot;}&lt;/p&gt;
&lt;h2&gt;How it works, in practice&lt;/h2&gt;
&lt;p&gt;Before sending a request, the bot signs some of its elements with its private key. In particular it signs the target &lt;strong&gt;authority&lt;/strong&gt; - the domain of the site it&apos;s writing to - so the signature only holds for that recipient and can&apos;t be reused elsewhere. The request then travels with three extra headers:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Signature-Input&lt;/code&gt; - describes &lt;em&gt;what&lt;/em&gt; was signed and with which parameters: a validity window (the moments it was created and when it expires), an identifier for the key used, and a tag flagging the purpose, &lt;code&gt;web-bot-auth&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Signature&lt;/code&gt; - contains the signature itself.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Signature-Agent&lt;/code&gt; - points to &lt;em&gt;where&lt;/em&gt; the bot&apos;s public keys can be found, in a standard format, so the site knows where to go and verify.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;In simplified form, a signed request looks like this:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;GET /article HTTP/1.1
Host: www.example.com
Signature-Agent: signer.example-bot.com
Signature-Input: sig=(&quot;@authority&quot; &quot;signature-agent&quot;);
  created=1700000000; expires=1700003600;
  keyid=&quot;ba3e64==&quot;; tag=&quot;web-bot-auth&quot;
Signature: sig=:abc...==:
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The validity window matters: the signature expires quickly, so even if someone intercepted it they couldn&apos;t reuse it for long. And because it&apos;s tied to the target domain, it won&apos;t work against a site other than the intended one.&lt;/p&gt;
&lt;p&gt;To make adoption easier, Cloudflare released working examples you can already use: an npm package (&lt;code&gt;web-bot-auth&lt;/code&gt;) to generate signatures with Ed25519 keys, a Chrome browser extension, a plugin for the Caddy web server that shows server-side verification, and a public test server to experiment against.&lt;/p&gt;
&lt;h2&gt;Why it&apos;s more reliable than IP allowlists&lt;/h2&gt;
&lt;p&gt;The practical difference is sharp. An IP list says, at best, &quot;this request comes from an address that &lt;em&gt;usually&lt;/em&gt; belongs to a certain operator&quot; - indirect information that goes stale and can be worked around. A cryptographic signature instead says &quot;this specific request, to this specific domain, within this time window, was produced by whoever holds that private key&quot;.&lt;/p&gt;
&lt;p&gt;You no longer have to chase addresses that change, or trust a User-Agent anyone can write. Verification doesn&apos;t depend on the network path: it works even if the bot goes through proxies or shared infrastructure. And the identity doesn&apos;t have to be arranged site by site: the bot publishes its key once, and anyone can verify it.&lt;/p&gt;
&lt;h2&gt;What changes for site operators&lt;/h2&gt;
&lt;p&gt;For someone running a site, the prospect is being able to decide more finely who gets in. Instead of reasoning by lists of addresses, you can reason by verified identities: grant access to a search engine crawler or to an AI agent you want to make room for, and treat the rest differently. Cloudflare has stated its intention to fold this mechanism into its own bot management and AI traffic analysis tools, in keeping with other recent moves such as &lt;a href=&quot;/en/changelog/cloudflare-oauth-self-managed&quot;&gt;self-managed OAuth&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;It&apos;s worth being clear that this signature proves &lt;em&gt;who&lt;/em&gt; sent the request, not &lt;em&gt;what&lt;/em&gt; they&apos;ll then do with it. A signed bot is still subject to the site&apos;s rules: authentication is the premise for applying sensible permissions, not an automatic pass.&lt;/p&gt;
&lt;h2&gt;Where it stands&lt;/h2&gt;
&lt;p&gt;Some caution is needed here, because none of this is settled yet. At launch, Web Bot Auth started as a &lt;strong&gt;closed beta&lt;/strong&gt;, that is a limited-access trial phase.&lt;/p&gt;
&lt;p&gt;The specifications describing it are IETF &lt;strong&gt;Internet-Drafts&lt;/strong&gt; (for example the draft on the architecture and the one on the format of the key directory): working documents, still evolving and not approved as standards. It&apos;s worth remembering that an Internet-Draft, on its own, has no official standing in the IETF process until it completes the path. The standard &lt;em&gt;underneath&lt;/em&gt; it, RFC 9421, is by contrast already published and stable.&lt;/p&gt;
&lt;p&gt;Cloudflare also described a more experimental alternative based on mTLS (mutual authentication at the TLS layer, with certificates on both client and server side), but it points to HTTP message signatures as the main route, because they&apos;re simpler to adopt without touching the TLS layer.&lt;/p&gt;
&lt;p&gt;In short: it&apos;s a concrete, already testable proposal, not a finished product. The idea of identifying bots with cryptographic proof rather than spoofable clues is sound, and it arrives at the right moment, with AI agents multiplying automated traffic. But its real value will depend on how many bot operators start signing and how many sites learn to verify. For now it&apos;s worth following, understanding how it works, and treating it as a complement to existing defences - not yet a replacement for them.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to manage bots and AI agents without blocking the visitors you actually want?&quot; text=&quot;We set up access rules, allowlists and bot management tooling tailored to your site or infrastructure.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.cloudflare.com/web-bot-auth/&quot;&gt;Forget IPs: using cryptography to verify bot and agent traffic (Cloudflare Blog)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc9421.html&quot;&gt;RFC 9421: HTTP Message Signatures (RFC Editor)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://datatracker.ietf.org/doc/draft-meunier-web-bot-auth-architecture/&quot;&gt;draft-meunier-web-bot-auth-architecture (IETF Datatracker)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>AI Inside the Browser: The Prompt API With Gemini Nano</title><link>https://initd.it/en/changelog/browser-ai-prompt-api</link><guid isPermaLink="true">https://initd.it/en/changelog/browser-ai-prompt-api</guid><description>Chrome exposes a Prompt API that talks to a local AI model, Gemini Nano. What it enables (summarizing, classifying, extracting without calling the cloud) and why it matters for privacy, latency, and cost.</description><pubDate>Tue, 20 May 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Almost every &quot;smart&quot; feature we use online - an automatic summary, a writing suggestion, an answer to a question - works the same way. The text leaves the device, travels to a server, gets processed by an AI model, and comes back. It&apos;s convenient, but it has three costs: the data leaves the device, there&apos;s a wait for the round trip, and every request costs money for whoever runs the service. Chrome&apos;s Prompt API tries to change that pattern. It brings the model inside the browser, onto the computer of the person browsing, so the work happens locally, without calling the cloud.&lt;/p&gt;
&lt;h2&gt;What the Prompt API is&lt;/h2&gt;
&lt;p&gt;An &lt;strong&gt;API&lt;/strong&gt; (application programming interface) is an agreed set of instructions that lets one program ask another for a service. So the Prompt API is the way a web page&apos;s or an extension&apos;s code can send a request to an AI model already built into Chrome.&lt;/p&gt;
&lt;p&gt;In plain terms: you write the request the way you&apos;d write it to an assistant (&quot;summarize this text&quot;, &quot;extract the name and email from this message&quot;, &quot;is this review positive or negative?&quot;) and the model answers. The word &lt;em&gt;prompt&lt;/em&gt; is exactly that natural-language request.&lt;/p&gt;
&lt;p&gt;The model doing the answering is called &lt;strong&gt;Gemini Nano&lt;/strong&gt;. It&apos;s a compact version of &lt;a href=&quot;/en/changelog/gemini-3&quot;&gt;Google&apos;s Gemini models&lt;/a&gt;, designed to run on an ordinary device rather than in a data center. One important detail: the model isn&apos;t shipped inside the browser. It&apos;s downloaded separately the first time a site or extension uses it, then it stays on the device, and later requests don&apos;t repeat the download.&lt;/p&gt;
&lt;h2&gt;What it lets you do&lt;/h2&gt;
&lt;p&gt;The Prompt API is general-purpose: it isn&apos;t tied to a single task. According to Chrome&apos;s documentation, the model can handle text reasoning and generation, classification, and content extraction and analysis. In practice that lines up with the jobs that come up most often on a page:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Summarize&lt;/strong&gt; a long article or a message thread down to a few lines.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Classify&lt;/strong&gt; a piece of text - for example, sorting requests into &quot;urgent&quot; and &quot;not urgent&quot;, or gauging the tone of a comment.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Extract&lt;/strong&gt; structured information from free text: a date and place from an invitation, a contact from an email signature.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Rewrite&lt;/strong&gt; or generate short text from instructions.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A less obvious point: the Prompt API doesn&apos;t only accept text. The documentation notes it can also take &lt;strong&gt;images and audio&lt;/strong&gt; as input. That opens up cases like describing the content of an image or transcribing a voice note - again, locally.&lt;/p&gt;
&lt;p&gt;For the most common tasks there are also dedicated APIs that are simpler to use because they&apos;re already specialized: among them the Summarizer, the Translator, the Language Detector, plus Writer, Rewriter, and Proofreader for writing, rewriting, and correcting. They belong to the same family of AI features built into the browser, an approach not unlike the way &lt;a href=&quot;/en/changelog/agent-skills&quot;&gt;Agent Skills package specific procedures&lt;/a&gt; for AI assistants.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your data really need to leave for an external AI service?&quot; text=&quot;We assess whether your site&apos;s or application&apos;s AI features can run locally in the browser, without sending data to third parties.&quot; button=&quot;Ask for an assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;Why it matters: privacy, latency, cost&lt;/h2&gt;
&lt;p&gt;The reason this is worth attention isn&apos;t &quot;there&apos;s AI in the browser&quot; - it&apos;s where the computation happens.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Privacy.&lt;/strong&gt; If the model runs on the device, the text (or image) to be processed doesn&apos;t have to be sent to an outside server. For sensitive content - personal notes, unpublished drafts, private messages - that&apos;s a real difference: the data never leaves the computer, which also matters for &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR compliance&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Latency.&lt;/strong&gt; Without the trip out to the cloud and back, the answer can arrive sooner. And once the model is downloaded, many requests can even work &lt;strong&gt;offline&lt;/strong&gt;, which is impossible when every operation depends on a remote server.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Cost.&lt;/strong&gt; Every call to a cloud model has a price for whoever builds the service. With local processing, that per-request cost isn&apos;t there: the work uses the device of the person browsing. For features used often, the difference on the final bill is real.&lt;/p&gt;
&lt;p&gt;None of these benefits kills off the cloud. &lt;a href=&quot;/en/changelog/cloud-run-gpu&quot;&gt;The large models running in data centers&lt;/a&gt; are still more capable. The point is having a choice: for simple, frequent tasks, the local option is often enough.&lt;/p&gt;
&lt;h2&gt;The status: what&apos;s ready and what isn&apos;t&lt;/h2&gt;
&lt;p&gt;Here honesty is needed, because the status isn&apos;t uniform.&lt;/p&gt;
&lt;p&gt;For &lt;strong&gt;Chrome extensions&lt;/strong&gt;, the Prompt API has reached a stable release: extension developers can use it in production. The path started with an &lt;em&gt;origin trial&lt;/em&gt; (a public testing phase open to those who sign up) that began with Chrome 131, and it later became available in a stable form.&lt;/p&gt;
&lt;p&gt;On &lt;strong&gt;regular web pages&lt;/strong&gt;, the situation is earlier-stage: access goes through an origin trial or a flag you enable by hand. In short, on the open web it&apos;s still an evolving technology, not something to build on without a fallback.&lt;/p&gt;
&lt;p&gt;There are also concrete requirements that limit availability. The documentation points to desktop devices (Windows 10 or 11, macOS 13 and later, Linux; on ChromeOS only Chromebook Plus) and &lt;strong&gt;not&lt;/strong&gt; Chrome on Android or iOS. It calls for free disk space (the docs cite around 22 GB) and a graphics card with more than 4 GB of dedicated memory, or enough RAM and CPU cores. Translation: not every visitor has a suitable device, and that has to be planned for.&lt;/p&gt;
&lt;h2&gt;A minimal example&lt;/h2&gt;
&lt;p&gt;The code below shows the basic pattern: first check whether the model is available, then create a session and send the request.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// 1. Check whether the model is usable on this device
const status = await LanguageModel.availability();

if (status !== &quot;unavailable&quot;) {
  // 2. Create a session (may download the model on first use)
  const session = await LanguageModel.create();

  // 3. Send a request and wait for the complete answer
  const answer = await session.prompt(
    &quot;Summarize in one sentence: &quot; + text
  );

  // 4. Free the resources when you&apos;re done
  session.destroy();
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;There&apos;s also &lt;code&gt;promptStreaming()&lt;/code&gt;, which returns the answer piece by piece as it&apos;s generated - handy for showing something to the user right away on longer text.&lt;/p&gt;
&lt;h2&gt;Limits to keep in mind&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;It&apos;s a small model.&lt;/strong&gt; Gemini Nano is less capable than the large cloud models. It does well on well-defined tasks (summarizing, classifying, extracting), less so on complex reasoning or very specific knowledge.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;It can be wrong.&lt;/strong&gt; Like any model of this kind, it sometimes produces incorrect or made-up answers. Treat the output as a draft, not as truth to use as-is for important decisions.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Availability varies.&lt;/strong&gt; Always check with &lt;code&gt;availability()&lt;/code&gt; before using the API, and plan an alternative (a cloud service, or a manual flow) for people without a suitable device.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;On the web it&apos;s still moving.&lt;/strong&gt; The interface can change during the trial phase. On the open web it&apos;s worth experimenting, but not yet depending on it for critical features.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;The Prompt API lets a page&apos;s or an extension&apos;s code talk to Gemini Nano, an AI model that runs inside Chrome, on the device. It&apos;s for summarizing, classifying, extracting, and generating text - and for images and audio too - without sending the data to the cloud. The benefits are clear: more privacy, less waiting, no per-request cost. The status, though, needs reading carefully: stable for extensions, still experimental on web pages, with device requirements that rule out a share of users. It isn&apos;t the end of the cloud, but one more option: bringing the AI to where the data is, instead of shipping the data to where the AI is.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to add AI features to your site with judgment?&quot; text=&quot;We build custom AI features for web applications, weighing case by case whether local browser processing or a cloud service makes more sense, with an eye on privacy and cost.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.chrome.com/docs/ai/prompt-api&quot;&gt;The Prompt API - Chrome for Developers&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.chrome.com/blog/prompt-api-origin-trial&quot;&gt;Join the Prompt API for Chrome Extensions origin trial - Chrome for Developers&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.chrome.com/docs/ai/built-in&quot;&gt;Built-in AI - Chrome for Developers&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>What Infrastructure as Code Is and Why It&apos;s Worth It</title><link>https://initd.it/en/changelog/terraform-getting-started</link><guid isPermaLink="true">https://initd.it/en/changelog/terraform-getting-started</guid><description>What Infrastructure as Code means: describing your infrastructure in versioned text files instead of configuring it by hand, the concrete benefits, the ideas of desired state and idempotency, and where Terraform fits.</description><pubDate>Thu, 15 May 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone who manages even a couple of servers knows the scene well. You log into a &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;cloud provider&apos;s&lt;/a&gt; control panel, click to create a virtual machine, open a few firewall ports by hand, wire up a domain. It works. Then, six months later, you need to build the exact same thing in a second environment, or rebuild in a hurry something that broke, and nobody remembers the precise sequence of clicks. That&apos;s exactly the problem &lt;strong&gt;Infrastructure as Code&lt;/strong&gt; sets out to solve.&lt;/p&gt;
&lt;h2&gt;What Infrastructure as Code is&lt;/h2&gt;
&lt;p&gt;Infrastructure as Code - usually shortened to &lt;strong&gt;IaC&lt;/strong&gt; - is the idea of describing your infrastructure in text files, instead of configuring it by hand by clicking through a panel. Rather than remembering which buttons to press, you write a document that states how everything should be: how many machines should exist, what size they are, which networks connect them, which firewall rules apply, which DNS records point where.&lt;/p&gt;
&lt;p&gt;A program reads those files and takes care of making the real infrastructure match the description. If the text says two servers should exist and there&apos;s only one, the program creates the second. If something no longer matches, it brings it back to what&apos;s written.&lt;/p&gt;
&lt;p&gt;The key point is that these files are plain text, just like the source code of a program. And like code, they can be kept in a &lt;strong&gt;version control&lt;/strong&gt; system such as Git - a tool that tracks every change, who made it and when. The infrastructure stops living only inside the provider&apos;s console and in the head of whoever built it, and becomes something you can read, share and rebuild.&lt;/p&gt;
&lt;h2&gt;Why it&apos;s worth it&lt;/h2&gt;
&lt;p&gt;The benefits aren&apos;t abstract. They address problems that show up every time an infrastructure grows or changes hands.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Repeatability.&lt;/strong&gt; The same file always produces the same result. Need a staging environment identical to production? Reuse the same description. Need to recreate an entire setup after a failure? Start from the text, not from memory. What used to be a long, forgetful manual procedure becomes a repeatable operation.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Review.&lt;/strong&gt; When infrastructure is text, every change can be read and discussed before it&apos;s applied, and checked by a machine the way it happens &lt;a href=&quot;/en/changelog/what-is-a-ci-cd-pipeline&quot;&gt;in a CI/CD pipeline&lt;/a&gt;, exactly the way it&apos;s done with an application&apos;s code. You can see in advance what will change, a colleague can check it, and there&apos;s a history of who changed what. Opening a firewall port stops being an invisible click and becomes a line someone wrote, with a date and a reason.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Fewer human errors.&lt;/strong&gt; Configuring lots of things by hand, often in a hurry, is fertile ground for mistakes: a rule forgotten on one server, a parameter that differs between two environments meant to be identical. Describing everything in a file and letting a machine apply it removes much of that waste. The same description produces the same infrastructure, with no variations introduced by tiredness or haste.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Documentation by default.&lt;/strong&gt; In most projects the infrastructure documentation either doesn&apos;t exist or is out of date. IaC eases the problem at the root: the files &lt;em&gt;are&lt;/em&gt; the up-to-date description of what actually runs, because they&apos;re the same thing that created it. There&apos;s no separate document that risks drifting from reality - reality is the document.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your infrastructure only exist in someone&apos;s muscle memory?&quot; text=&quot;We can check what happens if that person is on holiday or leaves the company.&quot; button=&quot;Request a review →&quot;}&lt;/p&gt;
&lt;h2&gt;Desired state and idempotency&lt;/h2&gt;
&lt;p&gt;Two concepts help explain how an IaC system works, and they show up in almost every tool.&lt;/p&gt;
&lt;p&gt;The first is &lt;strong&gt;desired state&lt;/strong&gt;. With the manual approach you issue imperative commands, one after another: &quot;create this machine&quot;, &quot;then open this port&quot;, &quot;then install that&quot;. IaC does the opposite: you describe the final result you want - the desired state - and leave the tool to work out which steps are needed to get there. You don&apos;t say &lt;em&gt;how&lt;/em&gt; to do it, you say &lt;em&gt;what&lt;/em&gt; should exist. This way of thinking is called declarative, and it has a practical benefit: the description stays valid whether you start from scratch or almost everything already exists.&lt;/p&gt;
&lt;p&gt;The second is &lt;strong&gt;idempotency&lt;/strong&gt;. It&apos;s a technical term for a simple idea: applying the same description once or ten times leads to the same result. If the infrastructure already matches what&apos;s written, applying it again creates no duplicates and changes nothing. That property is what makes IaC tools safe to re-run: there&apos;s no risk that running the same file twice doubles your servers. The tool compares what exists with what&apos;s described, and acts only on the difference.&lt;/p&gt;
&lt;h2&gt;What it looks like in practice&lt;/h2&gt;
&lt;p&gt;An IaC file looks like a series of orderly descriptions. Here, as an example, is how you might describe a single virtual machine with Terraform, one of the most widely used tools:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;resource &quot;aws_instance&quot; &quot;web&quot; {
  instance_type = &quot;t3.micro&quot;

  tags = {
    Name = &quot;web-server&quot;
  }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;You don&apos;t need to know the syntax to get the gist: the block says &quot;a virtual machine of this type, called web-server, should exist&quot;. It doesn&apos;t explain how to create it, it just states that it should exist. It&apos;s text, so it can be read, commented on, versioned.&lt;/p&gt;
&lt;p&gt;The typical work cycle is made of a few recurring steps. First you &lt;strong&gt;write&lt;/strong&gt; the description. Then you ask the tool for a preview - often called a &lt;em&gt;plan&lt;/em&gt; - which compares the text with reality and shows exactly what it would create, change or destroy, without touching anything yet. Only after reading and approving that preview do you &lt;strong&gt;apply&lt;/strong&gt; it, and at that point the tool carries out the changes in the right order. This preview step is one of the most important differences from manual work: you see what will happen before it happens.&lt;/p&gt;
&lt;h2&gt;Terraform and its ecosystem&lt;/h2&gt;
&lt;p&gt;When it comes to IaC for cloud infrastructure, the most frequently mentioned tool is &lt;strong&gt;Terraform&lt;/strong&gt;, developed by the company HashiCorp. The official documentation describes it as a tool that lets you &quot;build, change, and version cloud and on-prem resources safely and efficiently&quot;, defining them in human-readable configuration files.&lt;/p&gt;
&lt;p&gt;Terraform uses its own language, &lt;strong&gt;HCL&lt;/strong&gt; (HashiCorp Configuration Language), designed to be readable even by people who don&apos;t know it well. It doesn&apos;t talk to each platform directly: it uses &lt;strong&gt;providers&lt;/strong&gt;, components that translate the description into the specific calls of a service - &lt;a href=&quot;/en/changelog/aws-graviton5&quot;&gt;Amazon Web Services&lt;/a&gt;, &lt;a href=&quot;/en/changelog/cloud-run-gpu&quot;&gt;Google Cloud&lt;/a&gt;, Azure, and many others. HashiCorp and the community have written thousands of providers, available in a public registry, which is why the same approach works across very different platforms. Terraform also keeps a &lt;em&gt;state&lt;/em&gt; file it uses as a reference for what it has already created.&lt;/p&gt;
&lt;p&gt;One piece of context is worth knowing. In 2023 HashiCorp changed Terraform&apos;s license, moving from an open-source license to the more restrictive Business Source License. In response, part of the community created &lt;a href=&quot;/en/changelog/opentofu-terraform-alternative&quot;&gt;an independent derivative called OpenTofu&lt;/a&gt;, now hosted by the &lt;a href=&quot;/en/changelog/mcp-linux-foundation&quot;&gt;Linux Foundation&lt;/a&gt; and kept open source. For most people who use these tools to manage their own infrastructure the day-to-day practical difference is small, but it&apos;s useful to know when getting your bearings: Terraform remains the most widely used tool, and is no longer the only one.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Infrastructure as Code moves your infrastructure from a series of hard-to-remember clicks to a description in text files, readable and versioned. The benefits are concrete: you recreate everything the same way, you review each change before applying it, you cut down manual mistakes, and the description becomes the documentation itself. Two ideas sit underneath it: declaring the desired state instead of issuing step-by-step commands, and idempotency, which makes it safe to reapply the same description. Terraform is today the most widely used tool for this, but the real value isn&apos;t the tool - it&apos;s giving up trusting your infrastructure to memory and starting to write it down.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Ready to stop configuring servers by hand?&quot; text=&quot;We write and manage infrastructure as code with Terraform, across AWS, Google Cloud and other providers, from a first setup to migrating existing environments.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.hashicorp.com/terraform/intro&quot;&gt;What is Terraform? - HashiCorp&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.hashicorp.com/terraform/language/syntax/configuration&quot;&gt;Terraform - Configuration Syntax (HCL)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://opentofu.org/blog/opentofu-announces-fork-of-terraform/&quot;&gt;OpenTofu Announces Fork of Terraform&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Chrome Won&apos;t Remove Third-Party Cookies: What Changes</title><link>https://initd.it/en/changelog/chrome-third-party-cookies</link><guid isPermaLink="true">https://initd.it/en/changelog/chrome-third-party-cookies</guid><description>Google is dropping its &apos;cookieless&apos; plan and scaling back the Privacy Sandbox. What third-party cookies are, and what changes for analytics, advertising, and cross-site sign-on.</description><pubDate>Thu, 24 Apr 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;For years, one deadline shaped the plans of half the web: Chrome, the most-used browser in the world, was going to stop accepting third-party cookies, the ones that let a person be followed from one site to another. Whole industries - online advertising, traffic measurement, shared login systems - had started rebuilding their tools for a &quot;cookieless&quot; world. On 22 April 2025 Google announced that world isn&apos;t coming: Chrome will keep its current approach to third-party cookies, and won&apos;t even introduce the new choice prompt it had promised the year before. For people browsing, almost nothing changes. For anyone working with analytics, advertising, and sign-on across different sites, the ground they&apos;d been building on has shifted.&lt;/p&gt;
&lt;h2&gt;The news in brief&lt;/h2&gt;
&lt;p&gt;The announcement came on the &lt;strong&gt;Privacy Sandbox&lt;/strong&gt; blog, the project Google was using to try to replace third-party cookies. In short: Google is keeping the current third-party cookie choice system in Chrome and &lt;strong&gt;will not introduce a new dedicated prompt&lt;/strong&gt; asking users whether to accept or reject them. People continue to manage this preference where they already can today, in the browser&apos;s privacy and security settings.&lt;/p&gt;
&lt;p&gt;In the same post Google adds two things. First: the Privacy Sandbox technologies &quot;may have a different role to play&quot; than originally planned, and an updated roadmap would be shared in the following months. Second: tracking protections in Incognito mode continue, with so-called IP Protection - a feature that hides your network address in that mode - expected in the third quarter of 2025. This is a statement of direction, not a technical spec: the details of the new plan were, at that point, still to be defined.&lt;/p&gt;
&lt;h2&gt;What third-party cookies are&lt;/h2&gt;
&lt;p&gt;A &lt;strong&gt;cookie&lt;/strong&gt; is a small file a site asks the browser to save, so it can remember something between one visit and the next: that you&apos;re logged in, what&apos;s in your cart, your preferred language. So far it&apos;s handy and harmless.&lt;/p&gt;
&lt;p&gt;The difference lies in who sets the cookie. A &lt;strong&gt;first-party&lt;/strong&gt; cookie belongs to the site you&apos;re visiting, the one in the address bar. A &lt;strong&gt;third-party&lt;/strong&gt; cookie, on the other hand, is set by a different domain: typically an ad network, an analytics tool, a social button, or embedded content such as a video. Because the same provider is present on many different sites, that cookie lets it recognize the same person as they move from site to site. This is the mechanism behind &lt;strong&gt;cross-site tracking&lt;/strong&gt;: building a profile of what someone looks at across the web, mostly for advertising.&lt;/p&gt;
&lt;p&gt;It&apos;s worth being honest: third-party cookies don&apos;t only power intrusive ads. They also support legitimate uses, such as measuring whether a campaign led to a sale, avoiding showing the same ad a hundred times, and running some &lt;strong&gt;cross-site single sign-on&lt;/strong&gt; (SSO) systems, often built on top of protocols like &lt;a href=&quot;/en/changelog/oauth-security-bcp&quot;&gt;OAuth&lt;/a&gt;, where you authenticate once and stay recognized across several linked domains. That&apos;s why removing them touched so many balances at once.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your site still depend on third-party cookies for login or measurement?&quot; text=&quot;We map the real dependencies (SSO, ad pixels, analytics) and check what happens if a browser blocks them.&quot; button=&quot;Get a dependency map →&quot;}&lt;/p&gt;
&lt;h2&gt;How we got here&lt;/h2&gt;
&lt;p&gt;The story starts in 2019, when Google introduced the Privacy Sandbox with a stated goal: remove third-party cookies from Chrome and replace them with new technologies meant to do the same jobs (targeted advertising, measurement) without following the individual user. The idea looked good on paper, but the target was pushed back several times, because building alternatives acceptable to everyone - advertisers, publishers, regulators - proved hard.&lt;/p&gt;
&lt;p&gt;There&apos;s a regulatory front too. In 2022 Google entered a formal engagement with the UK&apos;s competition authority (the CMA) and its data protection authority (the ICO). The worry was that, by removing third-party cookies, Google might end up favoring its own advertising system at the expense of smaller competitors who depend on those cookies. A change sold as protecting privacy risked also becoming a matter of competition.&lt;/p&gt;
&lt;p&gt;The real turn came on 22 July 2024: instead of removing third-party cookies, Google announced it would introduce &quot;a new experience in Chrome&quot; letting users make a choice once, and change it whenever they wanted. Nine months later, on 22 April 2025, even that new prompt was shelved: what&apos;s already in the settings stays, with nothing added. In practice, in a little over a year the plan went from &quot;remove the cookies&quot; to &quot;let the user choose&quot; to &quot;don&apos;t change the current experience.&quot;&lt;/p&gt;
&lt;h2&gt;Why the U-turn matters&lt;/h2&gt;
&lt;p&gt;For people visiting sites, to repeat, the practical effect is minimal. The weight falls on those who build and run services.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Online advertising.&lt;/strong&gt; Many operators had invested time and money testing the new Privacy Sandbox interfaces - with names like Topics, Protected Audience, and Attribution Reporting - designed to replace cookies. Now that the deadline pushing that migration is gone, and Google itself says those technologies &quot;may have a different role to play,&quot; those investments sit in limbo. They aren&apos;t wasted, but they no longer have a date that makes them mandatory.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Measurement and analytics.&lt;/strong&gt; Attributing a conversion by following the user across different domains, for now, remains possible with third-party cookies where the browser accepts them. Anyone who&apos;d already started moving toward methods that don&apos;t depend on those cookies hasn&apos;t worked in vain, but the pressure to finish the switch quickly eases.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Sign-on across different sites.&lt;/strong&gt; Some shared authentication flows across domains lean on third-party cookies. Removing them would have broken those flows, forcing a rewrite. Chrome&apos;s decision lifts that urgency, at least for now.&lt;/p&gt;
&lt;h2&gt;It doesn&apos;t mean &quot;back to normal&quot;&lt;/h2&gt;
&lt;p&gt;It would be a mistake to read the announcement as a carefree return to the past. Some facts remain.&lt;/p&gt;
&lt;p&gt;Chrome is the most widespread browser, but it isn&apos;t the only one. Apple&apos;s &lt;strong&gt;Safari&lt;/strong&gt; and Mozilla&apos;s &lt;strong&gt;Firefox&lt;/strong&gt; have blocked third-party cookies by default for a while now. That means a significant share of traffic already runs without them: leaning everything on third-party cookies stays a fragile choice, regardless of what Chrome does.&lt;/p&gt;
&lt;p&gt;Chrome&apos;s protections in Incognito mode also remain, with IP Protection expected in the third quarter of 2025, after the browser had already extended its security work to other areas, such as &lt;a href=&quot;/en/changelog/chrome-post-quantum-tls&quot;&gt;post-quantum encryption for connections&lt;/a&gt;. And uncertainty remains over the future of the Privacy Sandbox itself, whose role is being redefined.&lt;/p&gt;
&lt;p&gt;Finally, a point browsers don&apos;t touch: privacy law. In Europe, the &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR&lt;/a&gt; and the ePrivacy rules still require the user&apos;s consent for tracking cookies. Whether Chrome accepts them or not, whoever runs a site has to ask for consent where required. Google&apos;s technical decision doesn&apos;t erase legal obligations.&lt;/p&gt;
&lt;h2&gt;What&apos;s worth doing now&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Don&apos;t dismantle what you&apos;ve already done.&lt;/strong&gt; The general direction of the web still points toward fewer third-party cookies, not more. Work done to reduce dependence on them keeps its value.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Lean on first-party data.&lt;/strong&gt; Information collected directly from your own site, with the user&apos;s consent, is more solid and less exposed to browser decisions.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Map your dependencies.&lt;/strong&gt; Know which features - SSO, embedded content, measurement - actually depend on third-party cookies, and have a fallback for each.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Follow the new roadmap.&lt;/strong&gt; Google promised an update in the following months; it&apos;s worth reading before making final decisions.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;Google has decided not to remove third-party cookies from Chrome, and not to introduce even the choice prompt announced in 2024: what&apos;s already in the settings stays. It&apos;s a reversal of years of &quot;cookieless&quot; plans, and it scales back the role of the Privacy Sandbox, whose future will be clarified by a later roadmap. For people browsing, almost nothing changes. For those working with advertising, analytics, and cross-site sign-on, the message is: don&apos;t rush, but don&apos;t kid yourself either - other browsers already block those cookies, and consent rules still stand. The road toward less tracking has just become less steep, not disappeared.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to prepare your site for the browsers&apos; next move?&quot; text=&quot;We set up GDPR-compliant cookie consent, first-party data, and alternatives to integrations that rely on third-party cookies, for Laravel systems and e-commerce.&quot; button=&quot;Let&apos;s talk about your site →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://privacysandbox.google.com/blog/privacy-sandbox-next-steps&quot;&gt;Next steps for Privacy Sandbox and tracking protections in Chrome - Privacy Sandbox (Google)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://privacysandbox.google.com/blog/privacy-sandbox-update&quot;&gt;A new path for Privacy Sandbox on the web - Privacy Sandbox (Google)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>TLS Certificates Heading to 47 Days: Automation Becomes Mandatory</title><link>https://initd.it/en/changelog/tls-certificates-47-days</link><guid isPermaLink="true">https://initd.it/en/changelog/tls-certificates-47-days</guid><description>The CA/Browser Forum has approved a phased reduction of TLS certificate lifetimes down to 47 days by 2029. What changes, why, and why manual renewal no longer holds up.</description><pubDate>Tue, 15 Apr 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Every site you reach over &lt;code&gt;https&lt;/code&gt; uses a certificate: a small digital document that proves the site really is who it claims to be, and that lets the browser encrypt the connection after a brief initial exchange, the &lt;a href=&quot;/en/changelog/tls-encrypted-client-hello&quot;&gt;TLS handshake&lt;/a&gt;. Nothing new so far. What&apos;s new is that these certificates will last far less than they do today. The body that sets the rules for the whole industry has approved a schedule that will cut the maximum lifetime from just over a year down to only 47 days by 2029. For people visiting sites, nothing changes. For the people running them, quite a lot does, because renewing a certificate by hand every month and a half isn&apos;t sustainable: automation stops being a nice-to-have and becomes a requirement.&lt;/p&gt;
&lt;h2&gt;The news in brief&lt;/h2&gt;
&lt;p&gt;The body that sets these rules is called the &lt;strong&gt;CA/Browser Forum&lt;/strong&gt;. It&apos;s where two groups meet: the &lt;strong&gt;Certificate Authorities&lt;/strong&gt; (CAs), the companies that issue certificates, and the browser makers such as Apple, Google, Microsoft, and Mozilla, who decide which certificates to trust. When these parties agree on a rule, that rule effectively applies to the entire public web.&lt;/p&gt;
&lt;p&gt;On 11 April 2025 the Forum approved a proposal identified as &lt;strong&gt;SC-081v3&lt;/strong&gt;. It was put forward by a representative from Apple and endorsed by Sectigo, Google, and Mozilla. So this isn&apos;t a draft or an idea still under discussion: it&apos;s a settled decision, with a precise and binding schedule. The vote passed with no objections: not one Certificate Authority and not one browser maker voted against it.&lt;/p&gt;
&lt;h2&gt;The schedule of cuts&lt;/h2&gt;
&lt;p&gt;The reduction doesn&apos;t happen all at once. It&apos;s spread across three steps, with fixed dates. Today a TLS certificate can last at most 398 days, a little over a year. From there it comes down like this:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;From 15 March 2026&lt;/strong&gt;: maximum lifetime &lt;strong&gt;200 days&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;From 15 March 2027&lt;/strong&gt;: maximum lifetime &lt;strong&gt;100 days&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;From 15 March 2029&lt;/strong&gt;: maximum lifetime &lt;strong&gt;47 days&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The dates mark when each limit takes effect for certificates issued from that day on. A certificate obtained before a cut-off stays valid for the term it was issued with; the new limit applies to later issuances. In practice the tightening is felt gradually, but the direction is one-way and won&apos;t reverse.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do you actually know how many TLS certificates you run and when they expire?&quot; text=&quot;We can run a quick inventory and check what a 47-day renewal cycle would mean for you.&quot; button=&quot;Request an inventory →&quot;}&lt;/p&gt;
&lt;h2&gt;Why shorten the lifetime&lt;/h2&gt;
&lt;p&gt;The natural question is: why make life harder? The main reason is security, and it turns on a simple idea, the &lt;strong&gt;window of compromise&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;A certificate is tied to a &lt;strong&gt;private key&lt;/strong&gt;, a secret file that must stay on the server and never leave it. If that key is stolen - through an attack, a misconfiguration, a backup ending up in the wrong place - whoever holds it can impersonate the site for as long as the certificate remains valid. The longer the certificate, the longer the window in which a theft goes unnoticed and does damage.&lt;/p&gt;
&lt;p&gt;In theory there&apos;s a remedy: &lt;strong&gt;revocation&lt;/strong&gt;, the ability to declare a certificate invalid before it expires. In practice revocation works poorly. Browsers don&apos;t always check whether a certificate has been revoked, and the mechanisms meant to warn them are slow or unreliable. Shortening the lifetime is a more solid way to get the same effect: a certificate that lasts a short time limits the damage on its own, because it expires before the problem can drag on. It&apos;s less elegant than revocation, but it actually works.&lt;/p&gt;
&lt;p&gt;There&apos;s a broader reason too. Certificates that last a year tend to be treated as things you configure once and forget. Shortening their life forces everyone to automate their management, and an automated, frequent process is safer than a manual, rare one: it makes fewer mistakes, doesn&apos;t rely on a person&apos;s memory, and doesn&apos;t leave certificates expired through oversight.&lt;/p&gt;
&lt;h2&gt;It&apos;s not just the expiry date&lt;/h2&gt;
&lt;p&gt;The same decision touches a second, less visible but equally important point: &lt;strong&gt;domain re-validation&lt;/strong&gt;. Before issuing a certificate for a site, the Certificate Authority has to confirm that whoever&apos;s asking actually controls the domain. This check is called &lt;strong&gt;Domain Control Validation&lt;/strong&gt; (DCV). Once it&apos;s done, today the result can be reused for a long time: you prove control of the domain once and it&apos;s taken as good for months.&lt;/p&gt;
&lt;p&gt;This reuse period is being shortened on the same schedule, down to just &lt;strong&gt;10 days from 15 March 2029&lt;/strong&gt;. That means it won&apos;t be enough to renew the certificate often: you&apos;ll also have to re-prove control of the domain often. Slow, manual methods - such as email-based verification or hand-placing a file on a server - become impractical at that frequency. You need a system that proves domain control on its own, automatically, every time it&apos;s needed.&lt;/p&gt;
&lt;h2&gt;Manual renewal no longer holds up&lt;/h2&gt;
&lt;p&gt;Put the pieces together. With a maximum lifetime of 47 days, every certificate has to be replaced before it expires, so in practice roughly every month. For someone running a single site it&apos;s a nuisance; for someone running dozens or hundreds it becomes impossible to keep up by hand. One forgotten renewal is all it takes for a site to show visitors the expired-certificate warning - that red screen that sends people running - with immediate damage to reputation and sales.&lt;/p&gt;
&lt;p&gt;The conclusion this decision points to explicitly is that certificate management needs to be &lt;strong&gt;automated&lt;/strong&gt;. Not as an optional improvement, but as the only way to keep pace with the required frequency.&lt;/p&gt;
&lt;h2&gt;The automation is called ACME&lt;/h2&gt;
&lt;p&gt;The tool to do this already exists and is widely used. It&apos;s called &lt;strong&gt;ACME&lt;/strong&gt; (Automatic Certificate Management Environment), a standard protocol - a shared language - with which a server can request, obtain, and renew certificates on its own, talking to the Certificate Authority without human intervention. It&apos;s the same mechanism made popular by &lt;a href=&quot;/en/changelog/lets-encrypt-6-day-ip-certificates&quot;&gt;&lt;strong&gt;Let&apos;s Encrypt&lt;/strong&gt;&lt;/a&gt;, the free authority that for years has issued certificates valid for 90 days precisely because they&apos;re designed to be renewed automatically.&lt;/p&gt;
&lt;p&gt;How it works, in plain terms: a program installed on the server proves to the Authority that it controls the domain, receives the certificate, installs it, and schedules its own renewal before expiry. All without anyone having to remember anything. The best-known client is called &lt;code&gt;certbot&lt;/code&gt;, but almost every modern control panel, load balancer, and &lt;a href=&quot;/en/changelog/cloud-provider-comparison&quot;&gt;cloud service&lt;/a&gt; already has ACME support built in. Anyone already using it has almost nothing to do: the shorter lifetime is, for them, a detail the system handles by itself.&lt;/p&gt;
&lt;p&gt;An example of the idea, using &lt;code&gt;certbot&lt;/code&gt;, to obtain and configure a certificate on a web server:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;certbot --nginx -d example.com -d www.example.com
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;From that point on, renewal happens automatically, usually through &lt;a href=&quot;/en/changelog/systemd-timers&quot;&gt;a scheduled task&lt;/a&gt; that runs several times a day and renews certificates as they approach expiry.&lt;/p&gt;
&lt;h2&gt;What&apos;s worth doing now&lt;/h2&gt;
&lt;p&gt;There&apos;s no rush for today, but the direction is clear, and it&apos;s worth getting ahead of it calmly rather than chasing deadlines later.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Take an inventory.&lt;/strong&gt; Know how many certificates you manage, where they are, and when they expire. There are often more than you remember.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Check what&apos;s already automatic and what isn&apos;t.&lt;/strong&gt; The certificates still renewed by hand are the ones that will cause trouble first.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Adopt ACME where it&apos;s missing.&lt;/strong&gt; Moving manual renewals to an automated client is the investment that pays off most, because it removes the fragile part of the process.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Don&apos;t forget mail servers.&lt;/strong&gt; With &lt;a href=&quot;/en/changelog/mta-sts-enforce-email-encryption&quot;&gt;MTA-STS&lt;/a&gt; in &lt;code&gt;enforce&lt;/code&gt; mode, an invalid certificate on the MX server makes senders stop delivering mail. The same goes for &lt;a href=&quot;/en/changelog/dane-tlsa-smtp-security&quot;&gt;DANE&lt;/a&gt;: if the certificate changes key and the TLSA record is not updated, senders stop delivering.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Don&apos;t wait for 2029.&lt;/strong&gt; Whoever automates now will pass through all three steps without noticing. Whoever puts it off will end up managing by hand a frequency that can&apos;t be managed by hand.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;TLS certificate lifetimes are stepping down to 47 days by 2029, along with the reuse period for domain checks, which drops to 10 days. It&apos;s a settled decision, not a proposal. The reason is to shrink the time in which a compromised certificate can do harm, in a world where revocation works poorly. For people browsing, nothing changes. For those running sites the message is blunt: manual renewal has an expiry date, and automation through ACME is the ready-made path to stop thinking about it.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Ready to take certificate renewal off your to-remember list?&quot; text=&quot;We set up ACME and automatic renewal across servers, reverse proxies and load balancers, so certificates renew themselves even on a few-week cycle.&quot; button=&quot;Let&apos;s automate it →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://cabforum.org/2025/04/11/ballot-sc081v3-introduce-schedule-of-reducing-validity-and-data-reuse-periods/&quot;&gt;Ballot SC081v3: Introduce Schedule of Reducing Validity and Data Reuse Periods - CA/Browser Forum&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.digicert.com/blog/tls-certificate-lifetimes-will-officially-reduce-to-47-days&quot;&gt;TLS Certificate Lifetimes Will Officially Reduce to 47 Days - DigiCert&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Brute Force Attacks: What They Are and How to Defend Against Them</title><link>https://initd.it/en/changelog/fail2ban-brute-force</link><guid isPermaLink="true">https://initd.it/en/changelog/fail2ban-brute-force</guid><description>What a brute force attack is, why every exposed service gets them, and the basic defenses: strong passwords and keys, multi-factor authentication, rate limiting, and tools like fail2ban.</description><pubDate>Thu, 10 Apr 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Every service reachable from the internet - a mailbox, a website&apos;s admin panel, &lt;a href=&quot;/en/changelog/bastion-host&quot;&gt;remote access to a server&lt;/a&gt; - sooner or later gets attempts to guess its credentials. Usually there&apos;s nothing personal about it: most of that traffic is automated and indiscriminate. Understanding what a &lt;strong&gt;brute force&lt;/strong&gt; attack is, why it&apos;s so common, and which basic defenses address it helps protect any exposed system without relying on magic solutions.&lt;/p&gt;
&lt;h2&gt;What a brute force attack is&lt;/h2&gt;
&lt;p&gt;A brute force attack is an attempt to guess a credential - a password, a code, a key - by trying many combinations one after another until one works. There&apos;s no cleverness to it: there&apos;s volume. The documentation from OWASP, the non-profit that focuses on web application security, describes it as configuring predetermined values, sending them to a server, and analyzing the response to see whether they worked. The name says it all: you&apos;re guessing, but many times and fast.&lt;/p&gt;
&lt;p&gt;The engine behind these attacks is automation. A human trying passwords by hand is painfully slow; a program tries thousands per second. Hence the classic distinction between two approaches. In &quot;pure&quot; brute force, combinations are generated one by one (every sequence of letters, numbers, and symbols): exhaustive but slow, and the longer the password, the slower it gets. A &lt;strong&gt;dictionary attack&lt;/strong&gt;, by contrast, starts from lists of common words and passwords, often collected from old data breaches: less exhaustive, but far faster at catching anyone using weak or already-known credentials.&lt;/p&gt;
&lt;h2&gt;Why every exposed service gets them&lt;/h2&gt;
&lt;p&gt;The most natural question is: why my server? In most cases the answer is that it isn&apos;t &quot;yours.&quot; Networks of compromised computers - so-called &lt;em&gt;botnets&lt;/em&gt; - sweep entire ranges of IP addresses looking for open ports and login pages. Once they find a target, they try default credentials, common passwords, and username/password pairs leaked from other services. It&apos;s background traffic, like noise in a city: anyone with an SSH port, a mail server, or a login form receives it, often thousands of attempts a day. And when the exposed port has a known flaw, as happened with &lt;a href=&quot;/en/changelog/mikrotik-routeros-ssh-vulnerabilities&quot;&gt;SSH on MikroTik routers&lt;/a&gt;, there is no need to guess at all.&lt;/p&gt;
&lt;p&gt;This changes how you should think about it. You don&apos;t need to be an &quot;interesting&quot; target: being reachable is enough. And because these attacks are automated and cheap, they don&apos;t stop on their own. The goal of defense isn&apos;t to become invisible, but to make each attempt costly and unrewarding enough that it leads nowhere.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Is your server already getting these attempts, without you knowing?&quot; text=&quot;We check your access logs and verify whether basic defenses like fail2ban and MFA are already in place.&quot; button=&quot;Ask for a check →&quot;}&lt;/p&gt;
&lt;h2&gt;Not one attack, but a family&lt;/h2&gt;
&lt;p&gt;The &quot;brute force&quot; label covers a few variants worth telling apart, because they call for slightly different defenses.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Dictionary attack.&lt;/strong&gt; As mentioned, it uses lists of frequent words and passwords instead of trying every combination. It&apos;s effective against predictable passwords like &lt;code&gt;password123&lt;/code&gt; or the company name.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Credential stuffing.&lt;/strong&gt; OWASP classifies this as a subset of brute force. Here the attacker doesn&apos;t guess: they reuse username/password pairs stolen in one breach to try them on other services. It works for a simple, widespread reason: many people reuse the same password everywhere. If it leaked from one site, it gets tried on all the others.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Password spraying.&lt;/strong&gt; The attacker tries a few very common passwords against a large number of accounts, rather than hammering a single one. This avoids the lockouts that trigger after too many failed attempts on the same user.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;The basic defenses&lt;/h2&gt;
&lt;p&gt;No single measure is enough. Effective protection is built from several layers that add up, so that when one fails the door isn&apos;t left wide open.&lt;/p&gt;
&lt;h3&gt;Strong passwords and keys&lt;/h3&gt;
&lt;p&gt;The first barrier is making the credential hard to guess. A long password dramatically increases the number of possible combinations, and therefore the time needed to try them all. OWASP&apos;s guidance recommends a minimum length of 15 characters when no second factor is in place, and suggests allowing passwords up to at least 64 characters so as not to penalize &lt;em&gt;passphrases&lt;/em&gt; - phrases that are easy to remember and hard to guess. Just as important is not reusing the same password across services: a password manager makes it easy to keep a different, random one for each, though where the service allows it the most effective move is replacing it altogether with a &lt;a href=&quot;/en/changelog/passkey-cross-platform&quot;&gt;passkey&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;On servers there&apos;s an even better option than passwords: &lt;strong&gt;cryptographic keys&lt;/strong&gt;. An SSH key is vastly longer and more random than any memorable password, to the point of making brute force practically useless. Replacing password login with key-based login removes much of the problem at the root, a measure that can be reinforced further by tucking access behind a &lt;a href=&quot;/en/changelog/wireguard-vpn&quot;&gt;VPN like WireGuard&lt;/a&gt;.&lt;/p&gt;
&lt;h3&gt;Multi-factor authentication (MFA)&lt;/h3&gt;
&lt;p&gt;Multi-factor authentication (MFA) requires, on top of the password, a second independent element: a temporary code from an app, a physical security key, a fingerprint. The idea is that guessing or stealing the password alone is no longer enough. According to OWASP, MFA is by far the best defense against most password-related attacks, brute force included; the same source cites a Microsoft estimate that it would have stopped 99.9% of account compromises. It&apos;s the single measure that moves the needle most: even if an attacker gets the password right, without the second factor they don&apos;t get in.&lt;/p&gt;
&lt;h3&gt;Slowing down and limiting attempts&lt;/h3&gt;
&lt;p&gt;If an attack lives on volume and speed, a natural defense is to take both away. &lt;strong&gt;Rate limiting&lt;/strong&gt; caps the number of attempts accepted within a given time window. Small pauses after each error, a temporary block after a set number of failures (&lt;em&gt;account lockout&lt;/em&gt;), or a CAPTCHA - those tests that are easy for a human and annoying for a program - make an attack slow and impractical.&lt;/p&gt;
&lt;p&gt;Honesty is needed here, though: OWASP warns that plain account lockout can backfire. An attacker can flood a legitimate user&apos;s account with wrong attempts on purpose just to lock them out, turning the defense into a small denial-of-service attack. That&apos;s why more targeted approaches are often preferred - tied to the device or the source address - which hit the origin of the abuse instead of the user.&lt;/p&gt;
&lt;h3&gt;Blocking the IPs that keep trying&lt;/h3&gt;
&lt;p&gt;The last layer is reacting to whoever keeps trying. There are tools that watch the system&apos;s logs, which should be kept only as long as the &lt;a href=&quot;/en/changelog/gdpr-infrastructure&quot;&gt;GDPR&apos;s data minimisation principles&lt;/a&gt; allow, and automatically block addresses that are too persistent. The best-known example in the Linux world is &lt;strong&gt;fail2ban&lt;/strong&gt;, free software that, as its official description puts it, scans log files (for example &lt;code&gt;/var/log/auth.log&lt;/code&gt;) and bans the IP addresses responsible for too many failed login attempts by updating the system firewall rules to reject new connections from them for a configurable amount of time. The same firewall also serves as a temporary stopgap when the flaw is in the kernel itself, as with &lt;a href=&quot;/en/changelog/cve-2026-98432-firewall-workaround-nftables&quot;&gt;the nftables rule for CVE-2026-98432&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;In practice: if an address gets the credentials wrong too many times in a short window, the door is shut on it for minutes or hours. It doesn&apos;t prevent the first attempt, but it silences the background noise and raises the cost of persistence. It&apos;s a good example of a reactive defense, complementary to - not a replacement for - the ones above.&lt;/p&gt;
&lt;h2&gt;The limits to keep in mind&lt;/h2&gt;
&lt;p&gt;Blocking IPs isn&apos;t a final solution, and it&apos;s fair to know that. An attack spread across thousands of different addresses, each with only a few attempts, can stay under the thresholds and never trigger a block; the same goes for &quot;slow&quot; attacks stretched out over time. And above all, no block based on failed attempts helps against credential stuffing that guesses the right password on the first try: there, the only real safety net is the second factor.&lt;/p&gt;
&lt;p&gt;That&apos;s the central point: there&apos;s no single tool that solves the problem. It&apos;s the sum of the layers - strong credentials, MFA, limits on attempts, and blocking abuse - that turns a brute force attack into little more than noise.&lt;/p&gt;
&lt;h2&gt;In summary&lt;/h2&gt;
&lt;p&gt;A brute force attack is the automated attempt to guess credentials by trying many of them quickly. Every exposed service receives them, because the attacks are automated, cheap, and indiscriminate. The basic defenses are few and reinforce one another: long, non-reused passwords (better still, cryptographic keys on servers), multi-factor authentication, limits on attempt frequency, and tools like fail2ban that block persistent addresses. None of these is enough on its own. Together, they turn a serious problem into a manageable nuisance.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to lock down access to your servers?&quot; text=&quot;We set up fail2ban, multi-factor authentication, and key-based login on the Linux servers we manage, with monitoring of suspicious access included in our on-call service.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://owasp.org/www-community/attacks/Brute_force_attack&quot;&gt;Brute force attack - OWASP&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://owasp.org/www-community/controls/Blocking_Brute_Force_Attacks&quot;&gt;Blocking Brute Force Attacks - OWASP&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html&quot;&gt;Authentication Cheat Sheet - OWASP&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://owasp.org/www-community/attacks/Credential_stuffing&quot;&gt;Credential stuffing - OWASP&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/fail2ban/fail2ban&quot;&gt;Fail2Ban - official project repository&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>A standard HTTP header to say an API is deprecated (RFC 9745)</title><link>https://initd.it/en/changelog/http-deprecation-header</link><guid isPermaLink="true">https://initd.it/en/changelog/http-deprecation-header</guid><description>The HTTP Deprecation header becomes an IETF standard: a machine-readable way to signal that an endpoint is being retired. What it is, how it works, and why it matters.</description><pubDate>Tue, 25 Mar 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Anyone who maintains an API eventually has to retire something: an address that&apos;s answered for years, a response format, a whole version of the service. The hard part isn&apos;t technical, it&apos;s communication. How do you warn the people using that API that it&apos;s about to disappear, without hoping someone reads the right email or the right note in the changelog? In March 2025 the IETF, the body that maintains Internet&apos;s technical standards, published RFC 9745 and turned a simple answer into a standard: the HTTP &lt;code&gt;Deprecation&lt;/code&gt; response header, one of many updates through which the IETF is expanding the protocol, alongside for instance the new &lt;a href=&quot;/en/changelog/http-query-method&quot;&gt;HTTP QUERY method&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;The problem: warning machines, not just people&lt;/h2&gt;
&lt;p&gt;A little vocabulary first, because it helps. An &lt;strong&gt;API&lt;/strong&gt; is the interface two programs use to talk to each other over the network. An &lt;strong&gt;endpoint&lt;/strong&gt; is one of the addresses that API exposes. A &lt;strong&gt;header&lt;/strong&gt; is a line of service information attached to every HTTP request and response, kept separate from the actual content. And to &lt;strong&gt;deprecate&lt;/strong&gt; a resource means declaring it still working but on its way out: you can use it, but you&apos;d better stop and move to something else.&lt;/p&gt;
&lt;p&gt;Until now, deprecation has almost always been announced in words: a blog post, an entry in the docs, an email to developers. That&apos;s fine for people, but not for software. A program calling an API a thousand times a day doesn&apos;t read the blog. It keeps hitting that endpoint until one day it stops answering, and at that point it&apos;s a production outage. What&apos;s missing is a way for the response itself to say, in a form a computer can read: &quot;heads up, this resource is being retired.&quot;&lt;/p&gt;
&lt;p&gt;That&apos;s exactly the gap RFC 9745 sets out to fill.&lt;/p&gt;
&lt;h2&gt;What RFC 9745 is&lt;/h2&gt;
&lt;p&gt;RFC 9745 is titled &lt;em&gt;The Deprecation HTTP Response Header Field&lt;/em&gt; and was published in March 2025 by the IETF, with Sanjay Dalal and Erik Wilde as authors. It defines a new response header, &lt;code&gt;Deprecation&lt;/code&gt;, with which a server signals to consumers of a resource that the resource &lt;strong&gt;will be, or has already been, deprecated&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;The mechanism is deliberately minimal. The server adds one line to its HTTP responses, and whoever receives them - a client, a monitoring tool, a library - can read it automatically. No change to the content, nothing breaks: just one extra signal.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do your APIs already signal when an endpoint is about to disappear?&quot; text=&quot;We review the lifecycle of the APIs you maintain and what happens when an endpoint needs retiring.&quot; button=&quot;Ask for a check →&quot;}&lt;/p&gt;
&lt;h2&gt;How you write it: a date, and that&apos;s it&lt;/h2&gt;
&lt;p&gt;The header&apos;s value is a date, expressed in the format of HTTP &lt;em&gt;Structured Fields&lt;/em&gt; (RFC 9651), the standard that defines how to write structured values inside headers so everyone reads them the same way. In practice the date is written as a Unix timestamp - the number of seconds elapsed since 1 January 1970 - prefixed with an at-sign. An example from the specification:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Deprecation: @1688169599
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;That number corresponds to 30 June 2023 at 23:59:59 UTC. The interesting bit is that the date can be in the &lt;strong&gt;future or in the past&lt;/strong&gt;. In the future it means &quot;this resource will be deprecated from that moment on&quot;: advance notice. In the past it means &quot;it&apos;s already been deprecated since then&quot;. With a single line the server conveys both the intent and the accomplished fact.&lt;/p&gt;
&lt;h2&gt;Deprecated doesn&apos;t mean switched off&lt;/h2&gt;
&lt;p&gt;There&apos;s a common misunderstanding to clear up here, and the RFC is explicit about it. Deprecating a resource &lt;strong&gt;does not change its behaviour&lt;/strong&gt;. A deprecated endpoint keeps working as before: it answers, it returns the same data, it doesn&apos;t change meaning. The header&apos;s presence isn&apos;t an error and doesn&apos;t force you to stop using it right away. It&apos;s a notice, not a closed door.&lt;/p&gt;
&lt;p&gt;Deprecation and retirement are two distinct moments. Deprecation says &quot;start moving&quot;; retirement (the &lt;em&gt;sunset&lt;/em&gt;) is the day the resource actually stops answering. Between the two there is, or should be, time to migrate.&lt;/p&gt;
&lt;h2&gt;Its natural companion: the Sunset header&lt;/h2&gt;
&lt;p&gt;To name that day there&apos;s another standard header, &lt;code&gt;Sunset&lt;/code&gt;, defined by RFC 8594. Where &lt;code&gt;Deprecation&lt;/code&gt; says &quot;deprecated from when&quot;, &lt;code&gt;Sunset&lt;/code&gt; says &quot;stops working from when&quot;. The two pair up nicely, and RFC 9745 adds a common-sense rule: the &lt;code&gt;Sunset&lt;/code&gt; date &lt;strong&gt;must not be earlier&lt;/strong&gt; than the &lt;code&gt;Deprecation&lt;/code&gt; date. It would make no sense to switch a resource off before you&apos;ve even declared it on its way out.&lt;/p&gt;
&lt;h2&gt;Saying what to use instead: the &quot;deprecation&quot; relation&lt;/h2&gt;
&lt;p&gt;A date on its own doesn&apos;t tell the whole story. It doesn&apos;t explain why the resource is being retired, what to use instead, or by when to finish the switch. That&apos;s why RFC 9745 also defines a &lt;em&gt;link relation&lt;/em&gt; called &lt;code&gt;deprecation&lt;/code&gt;: a standard way to link, again via a header, to a documentation page that holds the rest of the story. The specification&apos;s example is this:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Deprecation: @1688169599
Link: &amp;lt;https://developer.example.com/deprecation&amp;gt;;
      rel=&quot;deprecation&quot;; type=&quot;text/html&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The &lt;code&gt;Link&lt;/code&gt; header points to an address, and &lt;code&gt;rel=&quot;deprecation&quot;&lt;/code&gt; declares that this link is about the retirement itself. There the API provider can describe the deprecation policy, the timeline and - where one exists - the resource that replaces the old one, with a migration guide. The documentation can even set a clear rule, for instance that every deprecation will be announced a given number of days ahead of the switch-off date.&lt;/p&gt;
&lt;h2&gt;Why it matters for an API&apos;s lifecycle&lt;/h2&gt;
&lt;p&gt;The value of all this isn&apos;t the header itself, but the fact that a retirement notice is finally &lt;strong&gt;machine-readable&lt;/strong&gt;, the same principle behind other HTTP signals built for automated clients, like the one that lets sites &lt;a href=&quot;/en/changelog/pay-per-crawl&quot;&gt;charge AI crawlers&lt;/a&gt;. That changes several practical things.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;A client can notice on its own that it&apos;s calling a deprecated endpoint and write it into its own logs, instead of finding out on the day the endpoint dies.&lt;/li&gt;
&lt;li&gt;A monitoring tool can inspect responses and raise an alert when the header shows up, giving the team time to react.&lt;/li&gt;
&lt;li&gt;Anyone consuming dozens of different APIs can measure how much &quot;debt&quot; they&apos;ve built up - how many dependencies are about to vanish - without chasing changelogs written differently by each provider.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;In a word, managing an API&apos;s lifecycle stops depending on whether a person read the right message at the right time. The signal travels alongside the data.&lt;/p&gt;
&lt;h2&gt;Where it stands&lt;/h2&gt;
&lt;p&gt;A note on status, because it&apos;s easy to misread. RFC 9745 is a &lt;strong&gt;Proposed Standard&lt;/strong&gt;: not a draft, not an experimental document, but the first stable rung on the IETF standards track, the same level reached by the &lt;a href=&quot;/en/changelog/http-concealed-auth&quot;&gt;HTTP Concealed&lt;/a&gt; authentication scheme too. It means the text is mature, publicly reviewed and citable, and that the &lt;code&gt;Deprecation&lt;/code&gt; header has been registered permanently in the official HTTP field name registry. From here on, anyone designing APIs can adopt it knowing the meaning is fixed once and for all.&lt;/p&gt;
&lt;p&gt;What remains is adoption, which is up to individual providers: the header&apos;s value shows only when servers send it and clients read it. But the hard part - agreeing on a single, sensible format - is done. For anyone maintaining APIs, adding a &lt;code&gt;Deprecation&lt;/code&gt; header (and ideally a &lt;code&gt;Sunset&lt;/code&gt; one and a link to the docs) is a small gesture that makes a retirement far less painful for the people on the other side.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to retire your APIs without surprising the people who use them?&quot; text=&quot;We design and maintain Laravel APIs with deprecation headers, migration docs, and retirement timelines agreed with consumers.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc9745.html&quot;&gt;RFC 9745: The Deprecation HTTP Response Header Field (RFC Editor)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://datatracker.ietf.org/doc/rfc9745/&quot;&gt;RFC 9745 - The Deprecation HTTP Response Header Field (IETF Datatracker)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc8594.html&quot;&gt;RFC 8594: The Sunset HTTP Header Field (RFC Editor)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>What a Reverse Proxy Is (and Why Almost Every Site Uses One)</title><link>https://initd.it/en/changelog/nginx-reverse-proxy</link><guid isPermaLink="true">https://initd.it/en/changelog/nginx-reverse-proxy</guid><description>A reverse proxy explained in plain terms: an intermediary in front of your applications for TLS, caching, load balancing and security. The difference from a forward proxy, and why it&apos;s a common building block of the web.</description><pubDate>Thu, 20 Mar 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Behind almost every site you visit there&apos;s a component you never notice, precisely because it does its job by staying out of sight: the &lt;strong&gt;reverse proxy&lt;/strong&gt;. It isn&apos;t the program that builds the pages, nor the database that stores the data. It&apos;s the intermediary that sits in front of everything else and decides who gets in, how, and toward which service. Understanding what it is helps you read a site&apos;s architecture instead of picturing it as a black box.&lt;/p&gt;
&lt;h2&gt;What a reverse proxy is, in plain terms&lt;/h2&gt;
&lt;p&gt;A &lt;em&gt;proxy&lt;/em&gt; is, literally, an intermediary: a component that sits between two parties and passes messages from one to the other. A &lt;strong&gt;reverse proxy&lt;/strong&gt; is an intermediary that sits in front of one or more application servers. The visitor talks to the reverse proxy; the reverse proxy forwards the request to the right application, collects its response, and hands it back to the visitor. The client, that is the browser, never talks directly to the server that actually builds the page.&lt;/p&gt;
&lt;p&gt;A useful picture is the front desk of an office. Someone arriving doesn&apos;t wander the corridors looking for the right person: they go to the reception desk, which routes the request to whoever should handle it and brings the answer back. The desk is a single point of contact for many different offices. A reverse proxy does the same thing for web services.&lt;/p&gt;
&lt;h2&gt;The difference from a forward proxy&lt;/h2&gt;
&lt;p&gt;The word &quot;proxy&quot; on its own causes confusion, because there are two opposite kinds. The difference is which side the intermediary stands on.&lt;/p&gt;
&lt;p&gt;A &lt;strong&gt;forward proxy&lt;/strong&gt; sits in front of &lt;em&gt;clients&lt;/em&gt;. It&apos;s the intermediary a corporate network or a &lt;a href=&quot;/en/changelog/wireguard-vpn&quot;&gt;VPN&lt;/a&gt; places in front of users&apos; computers: when someone browses, the request goes through the forward proxy first, which then talks to the outside sites on their behalf. It&apos;s used to control and filter outbound traffic and, often, to hide the identity of the person browsing.&lt;/p&gt;
&lt;p&gt;A &lt;strong&gt;reverse proxy&lt;/strong&gt; sits in front of &lt;em&gt;servers&lt;/em&gt;. It&apos;s the intermediary a site&apos;s operator places in front of their own applications. MDN&apos;s documentation captures the contrast well: a forward proxy acts on behalf of clients and can hide their identity, whereas a reverse proxy can hide the identity of the servers. Same basic idea, opposite side: one protects who asks, the other protects who answers.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Is your application still exposed directly to the internet?&quot; text=&quot;We put a reverse proxy in front of your service: Nginx configuration, TLS certificates and hardening, with no downtime.&quot; button=&quot;Ask for a free assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;A single entry point for many services&lt;/h2&gt;
&lt;p&gt;The most concrete reason a reverse proxy is so common is that it provides &lt;strong&gt;a single entry point&lt;/strong&gt; for many services. On the internet a site is reachable on two standard ports: 80 for HTTP and 443 for HTTPS. But behind a single domain there can be several applications: the public site, the customer area, an API for the mobile apps, an admin panel.&lt;/p&gt;
&lt;p&gt;The reverse proxy listens on that one public port and, by looking at the requested domain name or path, decides which internal application each request goes to. The applications, for their part, listen only on the machine&apos;s local network, without being directly exposed to the internet. A minimal example with Nginx, one of the most widely used reverse proxies, makes the idea concrete:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;server {
    listen 443 ssl;
    server_name site.example.com;
    # ...TLS certificates...

    location / {
        proxy_pass http://127.0.0.1:3000;
    }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Here the proxy receives the encrypted connections from the outside and forwards them to an application running locally on port 3000. The visitor sees a single address; behind the scenes there can be a whole set of services.&lt;/p&gt;
&lt;h2&gt;TLS: encryption handled in one place&lt;/h2&gt;
&lt;p&gt;Today web traffic travels encrypted with &lt;strong&gt;TLS&lt;/strong&gt;, the protocol behind the HTTPS padlock. Handling encryption requires certificates, keys and configuration, and it isn&apos;t work you want to duplicate in every single application.&lt;/p&gt;
&lt;p&gt;The reverse proxy solves this with &lt;strong&gt;TLS termination&lt;/strong&gt;: it&apos;s the one that handles the encrypted &quot;handshake&quot; with the browser, decrypts incoming requests and encrypts outgoing responses, so the servers behind it don&apos;t have to. &lt;a href=&quot;/en/changelog/tls-certificates-47-days&quot;&gt;The certificates&lt;/a&gt; live in one place, the security configuration is updated in one place, and the internal applications can talk in plain HTTP on the local network, focusing on their own job.&lt;/p&gt;
&lt;h2&gt;Caching and compression: less repeated work&lt;/h2&gt;
&lt;p&gt;A reverse proxy can also keep a copy of responses it has already computed. That&apos;s &lt;strong&gt;caching&lt;/strong&gt;: if many users ask for the same image or the same page, there&apos;s no need to regenerate it every time. The first request pays the full cost toward the application; the following ones get the ready-made copy, much faster and without straining the origin server.&lt;/p&gt;
&lt;p&gt;At the same level sits &lt;strong&gt;compression&lt;/strong&gt;: the proxy can compress text, HTML and data before sending them, reducing the bytes that travel over the network and therefore &lt;a href=&quot;/en/changelog/ttfb-explained&quot;&gt;load times&lt;/a&gt;. These are optimizations that are convenient to set up once, in front of everything, instead of reimplementing them in each application.&lt;/p&gt;
&lt;h2&gt;Load balancing&lt;/h2&gt;
&lt;p&gt;When a single server isn&apos;t enough to handle the traffic, you run several copies of the same application and spread the requests across them. This task, &lt;strong&gt;load balancing&lt;/strong&gt;, is one of the classic uses of a reverse proxy.&lt;/p&gt;
&lt;p&gt;The proxy decides which server to forward each request to, according to a rule. Nginx, for example, uses &lt;em&gt;round robin&lt;/em&gt; by default, distributing requests to each available server in turn while taking any weights into account; alternatively it can send each request to the server with the fewest active connections (&lt;em&gt;least connections&lt;/em&gt;) or tie a client to the same server based on its address (&lt;em&gt;ip hash&lt;/em&gt;). The benefit is twofold: you handle more traffic and, if one server fails, the others keep responding.&lt;/p&gt;
&lt;h2&gt;Security: a filter in front of the application&lt;/h2&gt;
&lt;p&gt;Placing an intermediary in front of the servers also has defensive value. The first benefit is a &lt;strong&gt;smaller exposed surface&lt;/strong&gt;: the applications aren&apos;t reachable directly from the internet, only through the proxy. Anyone trying to attack them doesn&apos;t even know their real address, because the only thing that ever answers is the intermediary.&lt;/p&gt;
&lt;p&gt;The second is that the reverse proxy becomes the &lt;strong&gt;natural place to concentrate controls&lt;/strong&gt;: limiting the number of requests to block abuse (&lt;em&gt;rate limiting&lt;/em&gt;), &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;filtering suspicious traffic&lt;/a&gt;, applying access rules. Doing this in one spot, in front of everything, is simpler and more robust than scattering the same defenses across every application. The proxy&apos;s controls do not cover flaws in the kernel underneath it, though: for those, as with CVE-2026-98432, you need the kernel update and, in the meantime, &lt;a href=&quot;/en/changelog/cve-2026-98432-firewall-workaround-nftables&quot;&gt;a packet-level filter&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;Nginx and the others&lt;/h2&gt;
&lt;p&gt;Nginx is perhaps the most cited example, but a reverse proxy is a role, not a product. The same job is done by software like HAProxy, Apache, Caddy, Traefik or Envoy, by the load balancers cloud providers offer and, at global scale, by CDNs such as Cloudflare&apos;s, which are themselves reverse proxies in front of millions of sites.&lt;/p&gt;
&lt;p&gt;It&apos;s worth noting that the pattern isn&apos;t tied to HTTP alone: a reverse proxy can forward requests to applications over other protocols too, and in fact Nginx supports, besides HTTP, mechanisms like FastCGI, uwsgi, SCGI, memcached and gRPC. The concept stays the same regardless of the tool you pick.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;A reverse proxy is the intermediary that sits in front of web applications and acts as the single point of contact toward the outside world. From there it handles TLS encryption, caching and compression, spreads the load across several servers, and concentrates security controls, keeping the applications shielded from direct exposure. It isn&apos;t a flashy component and almost no user knows it&apos;s there, but that&apos;s exactly why almost every site uses one: it solves, in a single place, a set of problems that every application would otherwise have to face on its own.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want a reverse proxy in front of your infrastructure?&quot; text=&quot;We design and run reverse proxies in production: TLS termination, caching, load balancing and security rules tuned to your service.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Proxy_servers_and_tunneling&quot;&gt;Proxy servers and tunneling - MDN Web Docs&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.nginx.com/nginx/admin-guide/web-server/reverse-proxy/&quot;&gt;NGINX Reverse Proxy - official NGINX documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.nginx.com/nginx/admin-guide/load-balancer/http-load-balancer/&quot;&gt;HTTP Load Balancing - official NGINX documentation&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://docs.nginx.com/nginx/admin-guide/security-controls/terminating-ssl-http/&quot;&gt;NGINX SSL Termination - official NGINX documentation&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>NIST picks HQC: a second, backup post-quantum encryption algorithm</title><link>https://initd.it/en/changelog/nist-hqc-post-quantum</link><guid isPermaLink="true">https://initd.it/en/changelog/nist-hqc-post-quantum</guid><description>NIST has selected HQC as a backup post-quantum algorithm for encryption, built on different math than ML-KEM. What it is, the problem it addresses, and why having an alternative matters.</description><pubDate>Thu, 13 Mar 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;On March 11, 2025, &lt;strong&gt;NIST&lt;/strong&gt;, the U.S. body that defines many of the security standards used around the world, announced its choice of a new encryption algorithm called &lt;strong&gt;HQC&lt;/strong&gt;. The acronym is a mouthful, but the idea is simple: HQC will act as a backup for protecting data against a future threat, sitting alongside an algorithm chosen earlier. It&apos;s worth understanding what that means, what it protects against, and why having a second algorithm, rather than just one, is a sensible decision.&lt;/p&gt;
&lt;h2&gt;The news in brief&lt;/h2&gt;
&lt;p&gt;For several years NIST has run a public effort to select algorithms for &lt;strong&gt;post-quantum cryptography&lt;/strong&gt;, meaning encryption methods designed to hold up even against a kind of computer that doesn&apos;t yet exist in usable form. The first standards in this new family were published in 2024. Now another one joins them: HQC, chosen as a &lt;strong&gt;backup algorithm for encryption&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;The key word here is &quot;backup.&quot; HQC doesn&apos;t replace anything. The main algorithm for encryption remains &lt;strong&gt;ML-KEM&lt;/strong&gt;, already standardized. HQC stands beside it as a second option, kept ready in case the first one shows weaknesses down the road. It&apos;s the fifth algorithm NIST has selected on this path, and the second one aimed specifically at protecting data in transit.&lt;/p&gt;
&lt;h2&gt;The problem: the threat from quantum computers&lt;/h2&gt;
&lt;p&gt;To see why any of this is needed, start with the threat. Today most of what we do online is protected by cryptography: when the padlock appears in your browser, the data exchanged between your device and the site is scrambled so anyone intercepting it can&apos;t read it. That protection holds because today&apos;s computers don&apos;t have the power to break it in any reasonable amount of time.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Quantum computers&lt;/strong&gt; are a developing technology, built on physical principles different from those of ordinary computers. In theory, a powerful enough machine of this kind could one day break much of the cryptography we rely on now. Nobody knows for certain whether or when that moment will arrive: expert estimates range from more than a decade to several decades away.&lt;/p&gt;
&lt;p&gt;There&apos;s still a reason not to wait. Anyone intercepting encrypted traffic today can store and archive it, waiting to decrypt it once the technology allows. This strategy has a name, &quot;&lt;strong&gt;harvest now, decrypt later&lt;/strong&gt;.&quot; It means data meant to stay sensitive for years is already at risk today, even though the machine capable of unlocking it doesn&apos;t exist yet. That&apos;s why adopting resistant algorithms early matters, the same reason &lt;a href=&quot;/en/changelog/chrome-post-quantum-tls&quot;&gt;Chrome started enabling post-quantum key exchange by default&lt;/a&gt; on TLS connections.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do you know what happens to your encrypted data today if a quantum computer arrives one day?&quot; text=&quot;We review the cryptography running on your infrastructure and how much room there is to adopt post-quantum algorithms once they&apos;re ready.&quot; button=&quot;Ask for a review →&quot;}&lt;/p&gt;
&lt;h2&gt;What HQC is, and what it&apos;s built on&lt;/h2&gt;
&lt;p&gt;HQC stands for &lt;em&gt;Hamming Quasi-Cyclic&lt;/em&gt;. It&apos;s a &lt;strong&gt;key encapsulation mechanism&lt;/strong&gt; (KEM): put simply, it handles the opening moment of a secure connection, when two parties need to agree on a shared secret key without anyone else being able to discover it. That key is then used to encrypt everything else in the conversation. This step is the one most exposed to the &quot;harvest now, decrypt later&quot; strategy, so it&apos;s the first thing to secure.&lt;/p&gt;
&lt;p&gt;What makes HQC distinctive is the math it rests on. Every modern encryption algorithm relies on a mathematical problem believed to be very hard to solve. HQC is built on &lt;strong&gt;error-correcting codes&lt;/strong&gt;: techniques originally created to detect and fix errors in data as it&apos;s transmitted or stored, used for decades in areas like satellite communications, older CDs, and QR codes. From that principle you can derive a hard mathematical problem to build the protection on.&lt;/p&gt;
&lt;p&gt;Here lies the important difference from ML-KEM, the main algorithm. ML-KEM rests on a different area of math, called &lt;strong&gt;structured lattices&lt;/strong&gt;. Two algorithms, two different mathematical foundations. That&apos;s not a minor detail, as we&apos;ll see.&lt;/p&gt;
&lt;h2&gt;Why have an alternative: crypto-agility&lt;/h2&gt;
&lt;p&gt;The reason NIST chose a second algorithm, and one built on different math at that, comes down to caution. These algorithms are relatively new. They&apos;ve been studied hard by experts worldwide, but no one can completely rule out that a weakness might be found in the future. The history of cryptography is full of methods once thought solid and later broken.&lt;/p&gt;
&lt;p&gt;The most insidious risk is a &lt;strong&gt;systemic&lt;/strong&gt; one. If every available algorithm rested on the same mathematical principle, a single discovery that cracked that principle would put the whole system in jeopardy all at once. Having an alternative built on independent foundations reduces that danger: if a problem ever emerged with the lattices behind ML-KEM, HQC would be ready, and it uses no lattices at all. And vice versa. The head of NIST&apos;s post-quantum project explained the choice in just those terms: it helps to have a backup standard based on a different math approach, in case the first one one day turns out to be vulnerable.&lt;/p&gt;
&lt;p&gt;This way of thinking has a name: &lt;strong&gt;crypto-agility&lt;/strong&gt;, the ability to switch algorithms without having to rebuild everything from scratch. A system designed to be agile can move from one encryption method to another with relative ease as circumstances change. It&apos;s not a flashy quality, but it&apos;s what lets you react quickly if something goes wrong, rather than being stuck with a single solution.&lt;/p&gt;
&lt;h2&gt;Where things stand: timing and status&lt;/h2&gt;
&lt;p&gt;It&apos;s worth being precise on one point: the choice of HQC is the start of a process, not the end. At the time of the announcement there was no ready-to-use standard yet.&lt;/p&gt;
&lt;p&gt;NIST has laid out a roadmap. A &lt;strong&gt;draft standard&lt;/strong&gt; is expected within about a year of the announcement, so roughly in 2026. Once the draft is published, a public comment period of about 90 days follows, during which anyone can flag problems or propose changes. Only then does the &lt;strong&gt;final version&lt;/strong&gt; arrive, expected around 2027. Until that point HQC isn&apos;t an algorithm to put into production, but a settled choice whose standardization path has been announced.&lt;/p&gt;
&lt;p&gt;One honest technical detail is worth adding: at a comparable level of security, HQC tends to require more computing resources than ML-KEM. That&apos;s one reason it stays the second option rather than the first. It isn&apos;t meant to replace the main algorithm in everyday use, but to exist as a reliable alternative on different foundations.&lt;/p&gt;
&lt;h2&gt;What changes in practice&lt;/h2&gt;
&lt;p&gt;For most people, right now, nothing changes immediately. There&apos;s no action to take and no software to update by hand because of HQC. The move to post-quantum cryptography is a long process, happening mostly behind the scenes, in the updates to browsers, operating systems, and libraries, a process already measurable: &lt;a href=&quot;/en/changelog/post-quantum-adoption&quot;&gt;a growing share of web traffic&lt;/a&gt; already runs on post-quantum cryptography.&lt;/p&gt;
&lt;p&gt;For those who design or run systems, though, there&apos;s a principle to keep in mind: &lt;strong&gt;don&apos;t concentrate everything on a single algorithm&lt;/strong&gt;. The takeaway from this news is precisely crypto-agility. An infrastructure built so it can switch encryption methods in the future, without rewriting half the system, will be far easier to adapt as standards evolve, the same principle behind &lt;a href=&quot;/en/changelog/lets-encrypt-6-day-ip-certificates&quot;&gt;shortening the lifespan of TLS certificates&lt;/a&gt; to limit the damage when something goes wrong. There&apos;s no need to rush to adopt HQC today, but it&apos;s worth building in a way that lets you do so tomorrow without pain.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;NIST has chosen HQC as a backup post-quantum encryption algorithm, to sit alongside ML-KEM. Its main feature is the math it&apos;s built on, error-correcting codes, different from that of the main algorithm. That difference is the point: having two independent foundations makes the system more resilient over time, because a single discovery couldn&apos;t bring them both down together. The actual standard will arrive over the coming years, with a draft expected in 2026 and a final version around 2027. In the meantime, the lesson useful to everyone is simple: in security, having a plan B built on different foundations isn&apos;t a luxury, it&apos;s prudence.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want infrastructure ready to switch encryption algorithms without the pain?&quot; text=&quot;We design and run our clients&apos; server infrastructure with crypto-agility in mind: TLS, certificates and libraries that can be updated without rewriting everything from scratch.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.nist.gov/news-events/news/2025/03/nist-selects-hqc-fifth-algorithm-post-quantum-encryption&quot;&gt;NIST Selects HQC as Fifth Algorithm for Post-Quantum Encryption - NIST&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://csrc.nist.gov/pubs/fips/203/final&quot;&gt;FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard - NIST&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>SPF, DKIM and DMARC: What They Are and Why They Matter for Email</title><link>https://initd.it/en/changelog/spf-dkim-dmarc</link><guid isPermaLink="true">https://initd.it/en/changelog/spf-dkim-dmarc</guid><description>SPF, DKIM and DMARC explained in plain terms: who is allowed to send for a domain, the signature that proves integrity, and the rule for what to do when the checks fail.</description><pubDate>Tue, 18 Feb 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;There&apos;s a little-known detail about email: the sender of a message is remarkably easy to forge. The name and address you see in the &quot;From&quot; field are a bit like a return address scribbled on the back of an envelope: on their own, nothing guarantees they&apos;re real. Much of the world&apos;s spam, &lt;a href=&quot;/en/changelog/passkey-cross-platform&quot;&gt;phishing&lt;/a&gt;, and &lt;em&gt;spoofing&lt;/em&gt; (emails that impersonate someone else) rests on this weakness. SPF, DKIM, and DMARC are the three tools built to fix it. They all serve one purpose: proving that a message really comes from who it claims to come from.&lt;/p&gt;
&lt;h2&gt;The problem: email was born without checks&lt;/h2&gt;
&lt;p&gt;When email was designed, the network was small and made of machines that trusted each other. Writing your own name in the sender field was enough, because there was no reason to lie. That model never included any identity verification, and it stuck: still today, technically, anyone can send an email showing a &quot;From&quot; address that isn&apos;t theirs.&lt;/p&gt;
&lt;p&gt;The consequences are twofold, and it helps to keep them separate, because the three tools exist to address them. The first is security: a scammer can write &quot;on behalf of&quot; your bank or your company and fool whoever receives the message. The second is &lt;em&gt;deliverability&lt;/em&gt;, the ability of a legitimate email to actually land in the right inbox instead of the spam folder. The large providers filter enormous volumes of mail, and a sender they can&apos;t verify is, by definition, suspicious.&lt;/p&gt;
&lt;p&gt;SPF, DKIM, and DMARC aren&apos;t alternatives to one another: they work together, each on a piece of the problem. Let&apos;s take them one at a time.&lt;/p&gt;
&lt;h2&gt;SPF: who is allowed to send for a domain&lt;/h2&gt;
&lt;p&gt;SPF stands for &lt;em&gt;Sender Policy Framework&lt;/em&gt; and is defined in RFC 7208. It answers one precise question: which servers are authorized to send mail for a given domain?&lt;/p&gt;
&lt;p&gt;The idea is simple. The owner of a domain publishes, among the domain&apos;s public settings (the so-called DNS records, the &quot;address book&quot; that translates internet names), a list of the authorized sending servers. When a message arrives, the receiving server reads that list and checks whether the server delivering it is on it. If it is, the check passes; if it isn&apos;t, something&apos;s off.&lt;/p&gt;
&lt;p&gt;The analogy is a list at the post office: &quot;for this company, only these offices may send.&quot; A letter posted from an unauthorized office is treated with suspicion.&lt;/p&gt;
&lt;p&gt;In practice it&apos;s a single line of text, and a domain must have only one. It looks like this:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;example.com.  IN  TXT  &quot;v=spf1 include:_spf.provider.tld -all&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The final part, &lt;code&gt;-all&lt;/code&gt;, tells the receiver how to treat anyone not on the list: reject them. A softer alternative, &lt;code&gt;~all&lt;/code&gt;, means &quot;treat it as suspicious but don&apos;t reject it outright,&quot; which is handy in the early stages, when you aren&apos;t yet sure you&apos;ve listed all of your senders.&lt;/p&gt;
&lt;p&gt;SPF has an important limitation to keep in mind: it checks the message&apos;s &quot;path&quot; (the server that sends it), not its content. That&apos;s the reason it isn&apos;t enough on its own.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Do your emails end up in spam more often than they should?&quot; text=&quot;We check your domain&apos;s SPF, DKIM and DMARC setup and your company mail&apos;s deliverability.&quot; button=&quot;Get a check →&quot;}&lt;/p&gt;
&lt;h2&gt;DKIM: the signature that proves integrity&lt;/h2&gt;
&lt;p&gt;DKIM stands for &lt;em&gt;DomainKeys Identified Mail&lt;/em&gt; and is defined in RFC 6376. Where SPF verifies where a message comes from, DKIM verifies the message itself.&lt;/p&gt;
&lt;p&gt;It works with key-based cryptography, the same principle behind &lt;a href=&quot;/en/changelog/web-bot-auth&quot;&gt;digital signatures&lt;/a&gt;. The sending server applies to the message a signature computed with a &lt;em&gt;private&lt;/em&gt; key that it keeps secret. The receiver retrieves the matching &lt;em&gt;public&lt;/em&gt; key (again from the domain&apos;s DNS records) and uses it to verify the signature. If it checks out, two things are proven: the message really comes from that domain, and it wasn&apos;t altered in transit. If even a comma had changed along the way, the signature would no longer match.&lt;/p&gt;
&lt;p&gt;The analogy here is a wax seal on a letter. It doesn&apos;t just tell you who sent it: if the seal is intact, it also guarantees that no one opened and changed the envelope on the way.&lt;/p&gt;
&lt;p&gt;The signature travels inside a technical header of the message, invisible to the average user, called &lt;code&gt;DKIM-Signature&lt;/code&gt;. Two of its fields matter more than the rest: the signing domain (the &lt;code&gt;d=&lt;/code&gt; tag) and the &lt;em&gt;selector&lt;/em&gt; (the &lt;code&gt;s=&lt;/code&gt; tag), a label that lets a single domain keep several keys active and rotate them without interruption.&lt;/p&gt;
&lt;h2&gt;DMARC: the rule for what to do when checks fail&lt;/h2&gt;
&lt;p&gt;Two gaps remain. First: neither SPF nor DKIM tells the receiver what to do when a check fails. Second, and more subtle: both verify a &quot;technical&quot; domain that the user never sees, and neither guarantees it matches the address shown in the &quot;From&quot; field. A message could pass the checks on some arbitrary domain and display a completely different one to the user.&lt;/p&gt;
&lt;p&gt;DMARC closes both gaps. It stands for &lt;em&gt;Domain-based Message Authentication, Reporting, and Conformance&lt;/em&gt;; as of 2026 the current reference is RFC 9989, which replaced the long-standing RFC 7489 and &lt;a href=&quot;/en/changelog/oauth-security-bcp&quot;&gt;made DMARC a full standard&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Its first job is called &lt;em&gt;alignment&lt;/em&gt;. DMARC requires the domain verified by SPF or DKIM to match the one the user reads in the &quot;From&quot; field. If a message passes SPF or DKIM but on a different domain from the visible one, DMARC considers it not aligned. It&apos;s enough for one of the two checks to pass and be aligned for DMARC to be satisfied.&lt;/p&gt;
&lt;p&gt;Its second job is to give the instruction. The domain owner publishes a rule, again as a DNS record, stating what to do with messages that fail alignment. The three options are:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;p=none&lt;/code&gt;: do nothing special, just observe. This is the monitoring phase.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;p=quarantine&lt;/code&gt;: treat the message as suspicious, usually delivering it to the spam folder.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;p=reject&lt;/code&gt;: refuse the message, which isn&apos;t delivered at all.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The record lives at a dedicated address and looks like this:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;_dmarc.example.com.  IN  TXT  &quot;v=DMARC1; p=none; rua=mailto:report@example.com&quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;That &lt;code&gt;rua&lt;/code&gt; part introduces the third function, often the most useful: &lt;em&gt;reports&lt;/em&gt;. Receiving providers periodically send the domain owner summaries (documents in XML format) listing who has sent mail in its name and with what outcome. This is how you discover both who is abusing your domain and your own legitimate services you&apos;d forgotten about, say a back-office app or a newsletter platform. Without these reports, you&apos;re flying blind.&lt;/p&gt;
&lt;h2&gt;How the three fit together&lt;/h2&gt;
&lt;p&gt;Lined up, the three tools cover different, complementary aspects:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;SPF&lt;/strong&gt; verifies the path: which server the message comes from.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;DKIM&lt;/strong&gt; verifies integrity: the content is authentic and hasn&apos;t been tampered with.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;DMARC&lt;/strong&gt; ties the first two to the address the user actually sees, decides what to do when something&apos;s off, and provides the reports.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;None of the three is enough on its own. SPF without DMARC doesn&apos;t protect the visible address; DKIM without DMARC doesn&apos;t say what to do on failure; DMARC without SPF or DKIM has nothing to check. It&apos;s the combination that works.&lt;/p&gt;
&lt;p&gt;These tools authenticate the sender, but they do not make encryption of the hop between servers mandatory: that is what &lt;a href=&quot;/en/changelog/mta-sts-enforce-email-encryption&quot;&gt;MTA-STS&lt;/a&gt; and, if the domain has DNSSEC, &lt;a href=&quot;/en/changelog/dane-tlsa-smtp-security&quot;&gt;DANE&lt;/a&gt; are for.&lt;/p&gt;
&lt;h2&gt;Why they matter today&lt;/h2&gt;
&lt;p&gt;Until a few years ago, setting these up was seen as an optional good practice. Not anymore. Since 2024, Google and Yahoo explicitly require them from anyone sending large volumes of mail: according to Google&apos;s official guidelines, anyone sending more than 5,000 messages a day to Gmail accounts must have SPF and DKIM configured and an active DMARC rule, even just the minimal &lt;code&gt;p=none&lt;/code&gt;, with the visible address aligned to the SPF or DKIM domain. In practice, without these checks the email simply risks not arriving.&lt;/p&gt;
&lt;p&gt;It matters for low-volume senders too. A domain without authentication is a domain anyone can use for scams in the owner&apos;s name, and it&apos;s also a domain that spam filters treat with more suspicion.&lt;/p&gt;
&lt;h2&gt;How it&apos;s set up, in broad strokes&lt;/h2&gt;
&lt;p&gt;All three are configured in the same place, the domain&apos;s DNS records, and they don&apos;t require touching mail servers if you rely on a provider that supports them. The general pattern is this: publish the SPF record with the list of authorized senders, enable DKIM signing and publish its public key, then publish the DMARC record.&lt;/p&gt;
&lt;p&gt;The trickiest step is DMARC itself, and the recommended order is gradual: start at &lt;code&gt;p=none&lt;/code&gt;, read the reports to learn who really sends in your name, fix any legitimate senders left out, and only then tighten the rule toward &lt;code&gt;quarantine&lt;/code&gt; and eventually &lt;code&gt;reject&lt;/code&gt;. Doing it all at once risks blocking legitimate email you didn&apos;t know you had. The logic is simple: look first, decide later.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;SPF, DKIM, and DMARC are three answers to a birth defect of email: anyone can pretend to be someone else. SPF says who is authorized to send, DKIM signs the message to prove its integrity, and DMARC ties both checks to the visible address and decides what to do when they fail. Together they cut down on spoofing and phishing and help legitimate messages reach their destination. They&apos;re no longer an extra: they&apos;re the minimum for a domain&apos;s mail to be taken seriously.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to secure your domain&apos;s email?&quot; text=&quot;We configure and monitor SPF, DKIM and DMARC on the domains we manage, from the first record all the way to a reject policy.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc7208.html&quot;&gt;RFC 7208 - Sender Policy Framework (SPF), Version 1&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc6376.html&quot;&gt;RFC 6376 - DomainKeys Identified Mail (DKIM) Signatures&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc9989.html&quot;&gt;RFC 9989 - Domain-based Message Authentication, Reporting, and Conformance (DMARC)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://support.google.com/a/answer/81126?hl=en&quot;&gt;Email sender guidelines - Google Workspace Admin Help&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>HTTP Concealed (RFC 9729): authentication that hides a resource even exists</title><link>https://initd.it/en/changelog/http-concealed-auth</link><guid isPermaLink="true">https://initd.it/en/changelog/http-concealed-auth</guid><description>RFC 9729 defines an HTTP authentication scheme that won&apos;t even reveal whether a protected resource exists: what it is, the problem it solves, and what it&apos;s for.</description><pubDate>Tue, 11 Feb 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Most website login systems share a rarely discussed flaw: they&apos;re visible. Even without knowing the password, it&apos;s often easy to tell that something behind a given address is meant to be protected. In February 2025 the IETF, the body that maintains Internet&apos;s technical standards, published RFC 9729 and defined a new HTTP authentication scheme built to avoid exactly that. It&apos;s called &quot;Concealed&quot;.&lt;/p&gt;
&lt;h2&gt;The problem: locked doors you can still spot&lt;/h2&gt;
&lt;p&gt;When a browser asks for a page and the server requires access, it usually says so openly. The classic case is a response with status code &lt;code&gt;401 Unauthorized&lt;/code&gt; and a &lt;code&gt;WWW-Authenticate&lt;/code&gt; header, through which the server announces: &quot;you need to authenticate here&quot;. That&apos;s useful and correct behaviour on the vast majority of sites, but it has a side effect: anyone who tries that address learns there&apos;s a protected resource behind it.&lt;/p&gt;
&lt;p&gt;The RFC uses a precise term for this: traditional authentication schemes are &lt;em&gt;probeable&lt;/em&gt;. An unauthenticated client can send requests at random and watch the responses to work out where the server keeps something under lock and key. On a public site that&apos;s no problem. It becomes one when the goal is for certain services to stay invisible to anyone who doesn&apos;t already know they exist: a private panel, a management endpoint, a resource meant for a small group.&lt;/p&gt;
&lt;p&gt;The tricky part is that, for an attacker, knowing something exists is already half the work. An automated scanner sweeping through thousands of addresses feeds on exactly these differences in responses, the same kind of background traffic described in the piece on &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;brute force attacks&lt;/a&gt;. If the server treats a locked door differently from a door that isn&apos;t there, that difference is a clue.&lt;/p&gt;
&lt;h2&gt;What the &quot;Concealed&quot; scheme is&lt;/h2&gt;
&lt;p&gt;RFC 9729 defines a new cryptographic authentication scheme for HTTP with one extra property: it&apos;s &lt;em&gt;non-probeable&lt;/em&gt;. In practice, an outside observer can&apos;t tell a server that requires this kind of authentication apart from one that does nothing of the sort.&lt;/p&gt;
&lt;p&gt;The mechanism is built on asymmetric cryptography. The term is worth unpacking: every authorised user holds a pair of keys, one private (kept secret) and one public (shared with the server in advance). The server keeps a list mapping each key ID to its public key. Anyone wanting to authenticate proves they hold the private key by signing an agreed-upon piece of data; the server verifies that signature with the public key it has on file. No password ever travels across the wire.&lt;/p&gt;
&lt;p&gt;One practical point to keep in mind: the keys have to be distributed beforehand, by some other channel. The scheme assumes the server already knows which keys to accept. It isn&apos;t meant for signing up to just any site, but for letting in people who were added to the list ahead of time.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Can your private endpoints be spotted even by people without the right keys?&quot; text=&quot;We check how your infrastructure responds to unauthorized access attempts.&quot; button=&quot;Ask for a check →&quot;}&lt;/p&gt;
&lt;h2&gt;How it hides the resource&apos;s existence&lt;/h2&gt;
&lt;p&gt;The trick lies in how the data to be signed is generated. In classic cryptographic schemes, to stop an old signature from being reused, the server sends the client a one-time value (a &lt;em&gt;nonce&lt;/em&gt;) to fold into the signature. But that very message from the server is the giveaway: by announcing the nonce, the server is saying &quot;there&apos;s authentication here&quot;.&lt;/p&gt;
&lt;p&gt;RFC 9729 removes that step. The fresh data to be signed doesn&apos;t come from the server: the client derives it from the ongoing TLS connection, the same encryption that protects traffic on &lt;code&gt;https&lt;/code&gt; sites, the same foundation the extra privacy of &lt;a href=&quot;/en/changelog/tls-encrypted-client-hello&quot;&gt;Encrypted Client Hello&lt;/a&gt; rests on. TLS offers a function, the &lt;em&gt;keying material exporter&lt;/em&gt;, that lets client and server independently derive a secret value tied to that specific connection. Using a dedicated label - &lt;code&gt;EXPORTER-HTTP-Concealed-Authentication&lt;/code&gt; - the client obtains this value, signs it with its private key, and sends it. The server, for its part, can recompute the same value and verify it.&lt;/p&gt;
&lt;p&gt;The result is that the client speaks first, with no invitation needed. And here&apos;s the part that matters for privacy: a server that wants to stay truly invisible must respond identically whether the resource doesn&apos;t exist or exists but authentication failed. In practice it returns &lt;code&gt;404 Not Found&lt;/code&gt; in both cases. Anyone without the right key can&apos;t tell &quot;there&apos;s nothing here&quot; from &quot;there&apos;s something that isn&apos;t for you&quot;.&lt;/p&gt;
&lt;h2&gt;How it works, concretely&lt;/h2&gt;
&lt;p&gt;The authentication travels in the &lt;code&gt;Authorization&lt;/code&gt; header (or &lt;code&gt;Proxy-Authorization&lt;/code&gt; towards a proxy), using the &lt;code&gt;Concealed&lt;/code&gt; scheme and a handful of parameters. Without diving into the cryptographic detail, the five fields the specification defines are:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;k&lt;/code&gt;&lt;/strong&gt; - the ID of the key the client wants to use;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;a&lt;/code&gt;&lt;/strong&gt; - the public key the server uses to verify the signature;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;s&lt;/code&gt;&lt;/strong&gt; - the signature scheme in use, drawn from the standard TLS registry;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;p&lt;/code&gt;&lt;/strong&gt; - the &lt;em&gt;proof&lt;/em&gt; (the signature itself) attesting possession of the private key;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;v&lt;/code&gt;&lt;/strong&gt; - a &lt;em&gt;verification&lt;/em&gt; value tied to the TLS exporter output.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;One technical requirement applies: it needs TLS version 1.3, or 1.2 with the &lt;em&gt;extended master secret&lt;/em&gt; extension. The reason is that the signature must stay anchored to that single connection. The scheme works with HTTP/2, HTTP/3 and the QUIC transport.&lt;/p&gt;
&lt;h2&gt;What it&apos;s actually for&lt;/h2&gt;
&lt;p&gt;The main use case is keeping off the radar those services that shouldn&apos;t be stumbled upon. An &lt;a href=&quot;/en/changelog/bastion-host&quot;&gt;administration endpoint&lt;/a&gt;, a management interface, an internal API: with the Concealed scheme, anyone without a valid key has no way to tell that the address even does anything. It&apos;s a form of defence in depth: it doesn&apos;t replace the other protections, but it shrinks the surface an automated scanner can map.&lt;/p&gt;
&lt;p&gt;There&apos;s a tracking benefit too. The specification notes that the keys tie a user to a single origin (a single site), but are built so they can&apos;t be used to correlate requests across different sites. In other words, the same person doesn&apos;t become recognisable while moving from one domain to another.&lt;/p&gt;
&lt;h2&gt;What to watch out for&lt;/h2&gt;
&lt;p&gt;Like any tool, it has limits stated openly in the RFC.&lt;/p&gt;
&lt;p&gt;The signature is bound to the connection, not to the individual request. That opens a reuse risk: if the header carrying the proof were to leak - say, because of code running in the same browser session - it could be exploited on other requests over the same connection. That&apos;s why the RFC is blunt on one point: the keys used here must not be reused in other protocols.&lt;/p&gt;
&lt;p&gt;Then there&apos;s freshness. The signed value depends on the age of the TLS connection; a server wanting a more recent proof can force a new connection to be opened. And there&apos;s the matter of &lt;em&gt;timing side channels&lt;/em&gt;: if the server took different amounts of time to respond in the two cases - resource absent versus authentication failed - that millisecond difference could give away what was meant to stay hidden. Achieving genuinely indistinguishable responses takes care on this front too.&lt;/p&gt;
&lt;h2&gt;Where it stands&lt;/h2&gt;
&lt;p&gt;RFC 9729 isn&apos;t a draft: it&apos;s a published document, on the IETF standards track at the &lt;em&gt;Proposed Standard&lt;/em&gt; level. That&apos;s the first stable rung on the path: a mature, publicly reviewed specification, not yet the final &quot;Internet Standard&quot; level, the same stage reached recently by the &lt;a href=&quot;/en/changelog/http-deprecation-header&quot;&gt;HTTP header that flags deprecated APIs&lt;/a&gt;. Before reaching this point it was named &lt;code&gt;draft-ietf-httpbis-unprompted-auth&lt;/code&gt; and was developed in the IETF&apos;s httpbis working group.&lt;/p&gt;
&lt;p&gt;The authors are David Schinazi (Google), David M. Oliver (Guardian Project) and Jonathan Hoyland (Cloudflare). In concrete terms, support on the browser and server side is still early and needs checking case by case: the specification is solid, and how far it spreads across real tools is what the coming years will decide. It remains an interesting idea, because it shifts the goal of authentication from &quot;block access&quot; to &quot;don&apos;t even let on there&apos;s a door&quot;.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want your restricted services to actually stay hidden?&quot; text=&quot;We configure authentication, TLS, and reverse proxy rules so internal panels and endpoints stay invisible to anyone unauthorized.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/info/rfc9729/&quot;&gt;RFC 9729: The Concealed HTTP Authentication Scheme (RFC Editor)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://datatracker.ietf.org/doc/rfc9729/&quot;&gt;RFC 9729 - The Concealed HTTP Authentication Scheme (IETF Datatracker)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://datatracker.ietf.org/doc/draft-ietf-httpbis-unprompted-auth/&quot;&gt;draft-ietf-httpbis-unprompted-auth (IETF httpbis working group)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Passkeys Finally Go Truly Cross-Platform</title><link>https://initd.it/en/changelog/passkey-cross-platform</link><guid isPermaLink="true">https://initd.it/en/changelog/passkey-cross-platform</guid><description>Passkeys replace passwords with a cryptographic key pair. Since January 2025, the ones saved in Google Password Manager also sync to iPhone and iPad, on top of Android, Windows, macOS, Linux, and ChromeOS.</description><pubDate>Thu, 23 Jan 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Signing in to a site almost always means a password: a string to remember, one you can forget, reuse out of laziness, or hand by mistake to a scam page. Passkeys were created to replace that mechanism. They&apos;ve been around for a few years, but until now they carried a practical limit that held back adoption: a passkey created inside one ecosystem tended to stay there. In January 2025 Google announced a step that eases that limit. Passkeys saved in its manager, Google Password Manager, are now available on iPhone and iPad too, on top of Android, Windows, macOS, Linux, and ChromeOS. It&apos;s worth understanding what a passkey is, and why being able to use it across devices from different vendors changes things.&lt;/p&gt;
&lt;h2&gt;What a passkey is&lt;/h2&gt;
&lt;p&gt;A passkey is a way to sign in to a site or an app without typing a password. Instead of a secret word shared with the service, it uses a pair of cryptographic keys: two mathematical values tied to each other. One is the private key, and it stays on the user&apos;s device, protected and never shared with anyone. The other is the public key, handed to the site when you register.&lt;/p&gt;
&lt;p&gt;When you sign in, the site sends a small challenge to be signed. The device signs that challenge with the private key, but only after the user has unlocked as usual: fingerprint, face recognition, PIN, or pattern. The site verifies the signature with the public key it had on file and lets you in. For the user, the gesture is the same one already used to unlock the phone.&lt;/p&gt;
&lt;p&gt;This design has two practical consequences. First: there&apos;s no longer a password to steal. All the site&apos;s server keeps is the public key, which on its own doesn&apos;t let anyone in; a data breach no longer hands over &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;sign-in credentials&lt;/a&gt;. Second: the passkey is bound to the site&apos;s real address. A page that imitates your bank will never get a valid signature, because the address doesn&apos;t match. In practice &lt;a href=&quot;/en/changelog/spf-dkim-dmarc&quot;&gt;phishing&lt;/a&gt;, the trick that pushes people to type credentials into a fake site, stops working. Passkeys are built on open standards, WebAuthn and FIDO2, maintained by the FIDO Alliance together with the web standards body.&lt;/p&gt;
&lt;h2&gt;Why syncing was the real obstacle&lt;/h2&gt;
&lt;p&gt;On paper the mechanism is simpler and safer than a password. The problem, until now, wasn&apos;t the cryptography: it was portability. If the private key stays on the device, what happens when you have more than one device, perhaps from different vendors?&lt;/p&gt;
&lt;p&gt;The big providers answered by syncing passkeys, in encrypted form, across their own devices. But each did it inside its own fence. A passkey created on an iPhone ended up in Apple Passwords, the former iCloud Keychain, and stayed usable on Apple devices. A passkey created on Android or a computer, through Google Password Manager, lived in Google&apos;s world and didn&apos;t reach iPhone or iPad. Anyone with a phone from one vendor and a computer from another, or who switched phone brands, could end up without their passkey right where they needed it.&lt;/p&gt;
&lt;p&gt;That&apos;s a concrete obstacle. If users fear being locked out, they tend to keep the old password as a safety net, and the site has to keep supporting it. As long as the password stays as a fallback, the benefits of the passkey remain half realized. Syncing across different platforms is therefore the piece that decides whether passkeys become an everyday sign-in method or stay a convenience for people who live inside a single ecosystem.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your platform&apos;s login still rely only on passwords?&quot; text=&quot;We assess whether and how to bring passkeys into your users&apos; authentication system.&quot; button=&quot;Get an assessment →&quot;}&lt;/p&gt;
&lt;h2&gt;What Google announced&lt;/h2&gt;
&lt;p&gt;On January 16, 2025, on the Chrome for Developers blog, Google announced that Google Password Manager passkeys are available on iOS and iPadOS, starting with version 17. From then on, Chrome with the same signed-in profile syncs Google Password Manager passkeys across all platforms and devices: Android, iPhone and iPad, Windows, macOS, Linux, and ChromeOS.&lt;/p&gt;
&lt;p&gt;This is the piece that was missing. Syncing between computers and Android had already arrived a few months earlier, in September 2024, for Windows, macOS, Linux, and ChromeOS. iPhone and iPad had been left out: Google Password Manager passkeys weren&apos;t available there, and passkeys created on iOS ended up in Apple Passwords without reaching the other platforms. With this update a single manager, Google&apos;s, covers all the major desktop and mobile operating systems.&lt;/p&gt;
&lt;p&gt;One detail worth stressing about the tone: this isn&apos;t a beta or a limited trial. It&apos;s a stable, generally available feature. The requirement is iOS or iPadOS 17 or later; on iOS 16, passkeys are still saved to iCloud Keychain.&lt;/p&gt;
&lt;h2&gt;How you use it, in practice&lt;/h2&gt;
&lt;p&gt;On an iPhone or iPad updated to at least iOS 17, a Google Password Manager passkey is used by setting Chrome as an autofill provider in the system settings. From that point on, the passkeys saved in Google&apos;s manager become available in the apps and browsers on the device, not just inside Chrome.&lt;/p&gt;
&lt;p&gt;Access to those passkeys is protected by a Google Password Manager PIN. On a new device you need that PIN, or the screen-lock method of an already linked Android device, to restore your passkeys. It&apos;s worth setting up &lt;a href=&quot;/en/changelog/backup-3-2-1&quot;&gt;these recovery elements&lt;/a&gt; early, because they&apos;re the only way to get your passkeys back.&lt;/p&gt;
&lt;h2&gt;What to keep in mind&lt;/h2&gt;
&lt;p&gt;A few clarifications, so the announcement isn&apos;t read as broader than it is.&lt;/p&gt;
&lt;p&gt;The cross-platform syncing discussed here concerns one specific provider, Google Password Manager, and it goes through Chrome. On iPhone you have to set Chrome as the autofill provider; Google&apos;s passkeys don&apos;t merge with the ones in &lt;a href=&quot;/en/changelog/fido-credential-exchange&quot;&gt;Apple Passwords&lt;/a&gt;. Anyone who prefers to stay in the Apple ecosystem keeps using Apple Passwords, which in turn syncs across Apple devices. The change is that there&apos;s now at least one manager that spans all the main systems, iOS included.&lt;/p&gt;
&lt;p&gt;Google Password Manager passkeys are end-to-end encrypted: they&apos;re readable only on the user&apos;s device, and not even Google can access them. That&apos;s a privacy guarantee, but it has a flip side: if you lose both the PIN and the linked devices, recovery gets hard. That&apos;s why the recovery methods should be set up while everything works, not when you need them.&lt;/p&gt;
&lt;p&gt;Finally, it&apos;s worth remembering that a passkey doesn&apos;t erase the others. A site can let you register several passkeys, one per manager or device, and it&apos;s often wise to have more than one as a fallback. And the password, where it&apos;s still offered, is the layer to drop last, not to throw away on day one.&lt;/p&gt;
&lt;p&gt;In short, the news isn&apos;t the passkey itself, which already existed, but the fact that one manager now carries it uniformly across all the widespread operating systems. It&apos;s the kind of unshowy detail that decides whether a security technology stays niche or becomes something you use without thinking about it.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to bring passkeys into your application?&quot; text=&quot;We build and integrate WebAuthn/FIDO2 authentication into the Laravel and Vue applications we develop, from login to account management.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.chrome.com/blog/passkeys-gpm-ios&quot;&gt;Passkeys on Google Password Manager are now available on iOS (Chrome for Developers)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.chrome.com/blog/passkeys-gpm-desktop&quot;&gt;Chrome to sync passkeys on Google Password Manager between desktop and Android&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://fidoalliance.org/passkeys/&quot;&gt;FIDO Alliance: Passkeys&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>OAuth 2.0: the new security best practices (RFC 9700)</title><link>https://initd.it/en/changelog/oauth-security-bcp</link><guid isPermaLink="true">https://initd.it/en/changelog/oauth-security-bcp</guid><description>The IETF has published RFC 9700, the updated Best Current Practice for OAuth 2.0 security: what it is, what changes and why it matters for logins and APIs.</description><pubDate>Tue, 14 Jan 2025 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;In January 2025 the IETF - the body that maintains Internet&apos;s technical standards - published RFC 9700, titled &quot;Best Current Practice for OAuth 2.0 Security&quot;. The document gathers, in an official and updated form, the security rules recommended for anyone using OAuth 2.0, the mechanism behind the familiar &quot;Sign in with Google&quot; and behind much of the protected APIs on the web. It doesn&apos;t introduce a new protocol: it tidies things up, updates the existing advice and marks some now-risky practices as things to avoid.&lt;/p&gt;
&lt;h2&gt;What OAuth 2.0 is, briefly&lt;/h2&gt;
&lt;p&gt;OAuth 2.0 is a standard for delegated authorization. Put simply: it lets an application get limited access to a service on behalf of a person, without that person having to hand their password over to the application. It&apos;s what happens when a site offers &quot;Sign in with Google&quot; or &quot;Connect your account&quot;. The origin service verifies the identity and issues the application a token - a temporary pass that acts as an access permission, with precise limits on what it can do and for how long.&lt;/p&gt;
&lt;p&gt;The benefit is clear. The password stays with the origin service, the application receives only the minimum it needs, and that permission can be revoked at any time. That&apos;s exactly why OAuth 2.0 has become the backbone of logins and APIs across much of the web: from social networks to cloud platforms to integrations between business software.&lt;/p&gt;
&lt;p&gt;Three terms are worth clarifying up front, as they&apos;ll come back. An &lt;em&gt;access token&lt;/em&gt; is the pass that grants access to a resource. An &lt;em&gt;authorization code&lt;/em&gt; is an intermediate step: a short code the application then exchanges for the actual token. A &lt;em&gt;redirect URI&lt;/em&gt; is the address the service sends the user back to after consent, and where it delivers that code.&lt;/p&gt;
&lt;h2&gt;Why an updated reference matters&lt;/h2&gt;
&lt;p&gt;OAuth 2.0 was published in 2012 (RFC 6749). It has been adopted almost everywhere since, and with adoption at scale came attacks and pitfalls that weren&apos;t clear at first. The original security rules turned out to be too generic in some places and outdated in others.&lt;/p&gt;
&lt;p&gt;RFC 9700 exists for this reason. It&apos;s a &lt;em&gt;Best Current Practice&lt;/em&gt; - BCP for short, numbered 240 - meaning a document that doesn&apos;t describe a new technical standard but collects the best practice the community recommends at a given moment. Concretely, it updates and extends three earlier documents: the base OAuth 2.0 specification (RFC 6749), the rules on using &quot;bearer&quot; tokens (RFC 6750) and the older threat model (RFC 6819). The stated aim is to fold in the experience gathered in the field and to cover new threats that arose from the protocol&apos;s ever-wider use.&lt;/p&gt;
&lt;p&gt;An important point: this isn&apos;t a draft or a proposal. It&apos;s a document published in January 2025, at the level of official &quot;current practice&quot;. The authors are Torsten Lodderstedt (SPRIND), John Bradley (Yubico), Andrey Labunets and Daniel Fett (Authlete), well-known names in the &lt;a href=&quot;/en/changelog/passkey-cross-platform&quot;&gt;digital identity&lt;/a&gt; space.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Is your application still using the implicit grant or direct passwords?&quot; text=&quot;We review your OAuth setup: PKCE, redirect URIs and token rotation.&quot; button=&quot;Get a review →&quot;}&lt;/p&gt;
&lt;h2&gt;The main recommendations&lt;/h2&gt;
&lt;p&gt;The text is long and detailed, but a handful of points capture the direction well.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;PKCE for public applications.&lt;/strong&gt; PKCE is a mechanism that ties the initial request to the final code exchange, so that an intercepted code isn&apos;t enough on its own to obtain the token. The RFC makes it mandatory for &quot;public&quot; clients - mobile apps and applications running in the browser, which can&apos;t safely keep a secret - and recommends it for the others too. &lt;a href=&quot;/en/changelog/cloudflare-oauth-self-managed&quot;&gt;Authorization servers&lt;/a&gt; must support it and verify it, so an attacker can&apos;t work around it.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Exact matching of redirect URIs.&lt;/strong&gt; The server must compare the return address against the ones registered in advance character by character, with no shortcuts. It&apos;s a defense against hijacking the authorization code toward a site the attacker controls. The one practical exception concerns native apps on &quot;localhost&quot;, where the port number may vary.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Tokens bound to who uses them.&lt;/strong&gt; A classic risk is &lt;a href=&quot;/en/changelog/fail2ban-brute-force&quot;&gt;token theft&lt;/a&gt;: whoever steals it can reuse it. The RFC recommends &lt;em&gt;sender-constrained tokens&lt;/em&gt; - tokens tied to the legitimate client - via mutual TLS (RFC 8705) or DPoP (RFC 9449). In practice the token alone isn&apos;t enough: &lt;a href=&quot;/en/changelog/web-bot-auth&quot;&gt;proof of being the original holder&lt;/a&gt; is also required.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Refresh token protection.&lt;/strong&gt; A &lt;em&gt;refresh token&lt;/em&gt; is a longer-lived pass used to obtain new access tokens without logging in again. For public applications the RFC asks that it too be bound to the client, or that it be rotated - replaced on each use - so that a stolen token soon stops working.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Defense against &quot;mix-up&quot; attacks.&lt;/strong&gt; When an application talks to several authorization servers, an attacker can try to confuse the responses between one and another. The required countermeasure is to clearly identify who issued the response (through the &lt;code&gt;iss&lt;/code&gt; parameter) or to use distinct return addresses for each server.&lt;/p&gt;
&lt;p&gt;To these are added two ground rules: authorization responses must never travel over unencrypted connections, and it&apos;s worth relying on the authorization server&apos;s metadata to enable security options automatically, which reduces configuration mistakes.&lt;/p&gt;
&lt;h2&gt;What is discouraged or removed&lt;/h2&gt;
&lt;p&gt;Part of RFC 9700&apos;s value lies in what it takes away.&lt;/p&gt;
&lt;p&gt;The &lt;em&gt;implicit grant&lt;/em&gt; is dropped - an old flow that delivered the access token directly in the browser response: convenient once, but exposed to token leakage and reuse. The authorization code flow with PKCE should be used in its place.&lt;/p&gt;
&lt;p&gt;The &lt;em&gt;resource owner password credentials&lt;/em&gt; flow is excluded entirely - the one where the user types their password directly into the application, which then passes it on to the service. It defeats the very point of OAuth (keeping the password out of the application&apos;s hands) and is incompatible with multi-factor authentication. The RFC states plainly that it must not be used.&lt;/p&gt;
&lt;h2&gt;Why it matters for those exposing logins and APIs&lt;/h2&gt;
&lt;p&gt;For anyone running a service with social login or protected APIs, RFC 9700 is the reference to align with. It doesn&apos;t demand rewriting everything tomorrow, but it says clearly what counts as secure today and what doesn&apos;t.&lt;/p&gt;
&lt;p&gt;It works as a practical checklist: confirm that PKCE is in place, that redirect URIs are matched exactly, that the &lt;em&gt;implicit&lt;/em&gt; and &lt;em&gt;password&lt;/em&gt; flows have been retired, that refresh tokens are rotated or bound. Developers building integrations now have a single, citable document to point to in technical decisions and security reviews. And anyone relying on third-party libraries or identity providers can use it as a yardstick to check whether they follow the updated practice.&lt;/p&gt;
&lt;p&gt;The underlying message is simple: OAuth 2.0 remains valid, but the secure way to use it has been refined by experience. Having that way written down, in an official document, helps cut the most common mistakes.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Need to secure logins and APIs to RFC 9700 standards?&quot; text=&quot;We design and manage authentication for Laravel applications and API integrations: PKCE, bound tokens, access monitoring.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://datatracker.ietf.org/doc/rfc9700/&quot;&gt;RFC 9700: Best Current Practice for OAuth 2.0 Security (IETF Datatracker)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://www.rfc-editor.org/rfc/rfc9700.html&quot;&gt;RFC 9700 (RFC Editor)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://oauth.net/2/oauth-best-practice/&quot;&gt;OAuth 2.0 Security Best Current Practice (oauth.net)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>What the Model Context Protocol (MCP) Is and Why People Are Talking About It</title><link>https://initd.it/en/changelog/what-is-mcp</link><guid isPermaLink="true">https://initd.it/en/changelog/what-is-mcp</guid><description>Anthropic has introduced MCP, an open standard for connecting AI assistants to data and tools. What it is, the problem it solves, and why a standard matters, explained simply.</description><pubDate>Mon, 25 Nov 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Assistants based on artificial intelligence can write text and answer questions, but on their own they don&apos;t &quot;see&quot; the data of the people using them: the files on a disk, the messages in a work chat, the rows in a database. To let them use that information, you need a connection. And until recently, every connection was a job of its own, built to measure. On November 25, 2024, Anthropic, the company that develops the Claude assistant, introduced the &lt;strong&gt;Model Context Protocol&lt;/strong&gt; (MCP): an open standard meant precisely to make those connections uniform.&lt;/p&gt;
&lt;p&gt;It&apos;s worth understanding what that means, because behind a technical name there&apos;s a simple idea that concerns anyone who uses or builds tools with AI.&lt;/p&gt;
&lt;h2&gt;The problem: too many hand-built integrations&lt;/h2&gt;
&lt;p&gt;An AI assistant becomes truly useful when it can draw on real data and tools, not just the knowledge it was trained on. The catch is that this data lives in many different places: a document archive, a mailbox, a business system, a database. Each of these places speaks its own language and has its own way of being queried.&lt;/p&gt;
&lt;p&gt;Until not long ago, for each source you had to write a dedicated piece of code, that is, an &lt;strong&gt;integration&lt;/strong&gt;: a custom bridge between the assistant and that single service. It works, but it doesn&apos;t scale. With many assistants on one side and many services on the other, the number of bridges to build and maintain explodes. In plain terms: if there are five AI applications and ten tools, without a common language you potentially need fifty different connections, all to be written, tested, and updated whenever something changes.&lt;/p&gt;
&lt;p&gt;This is the classic problem of fragmented integrations: many, all different, all fragile. And it&apos;s exactly the problem MCP tries to remove.&lt;/p&gt;
&lt;h2&gt;An analogy: the universal port&lt;/h2&gt;
&lt;p&gt;A simple way to grasp it is to think of cables. Before the USB standard spread, every device had its own connector: one cable for the printer, one for the camera, one for the phone, each incompatible with the others. Then a common port arrived, and that tangle shrank to a single kind of connection.&lt;/p&gt;
&lt;p&gt;MCP aims to do the same for AI assistants. The official documentation describes it exactly as &quot;a USB-C port for AI applications&quot;: a standardized way to connect an assistant to external data sources and tools, instead of many bespoke connections. A &lt;strong&gt;protocol&lt;/strong&gt;, in this context, is simply a shared set of rules for how two programs exchange messages. If both sides follow the same rules, they understand each other without needing an adapter built just for them.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Want to connect AI to your company&apos;s data without hand-built integrations every time?&quot; text=&quot;We assess whether a custom MCP server makes sense for your case, and with what permissions it should be exposed.&quot; button=&quot;Assess your MCP project →&quot;}&lt;/p&gt;
&lt;h2&gt;How it works: clients and servers&lt;/h2&gt;
&lt;p&gt;MCP separates two roles, and understanding them helps you see why the scheme is clean.&lt;/p&gt;
&lt;p&gt;On one side there&apos;s the &lt;strong&gt;MCP server&lt;/strong&gt;: a small program that &quot;exposes&quot; a data source or a tool while speaking the language of the standard. For example, a server can give access to a folder of documents, to a database, or to the functions of a service. The server states, in a uniform way, what it makes available and how to use it.&lt;/p&gt;
&lt;p&gt;On the other side there&apos;s the &lt;strong&gt;client&lt;/strong&gt;, that is, the AI application that wants to use those data or tools, such as the assistant itself. The client connects to the server and, following the same rules, can read information or request actions. The connection is &lt;strong&gt;two-way&lt;/strong&gt;: the assistant not only receives data, but can also ask the server to do something.&lt;/p&gt;
&lt;p&gt;The advantage of this scheme is that the two sides don&apos;t need to know each other in advance. An assistant that &quot;speaks MCP&quot; can connect to any MCP server, and an MCP server can be used by any compatible assistant. It&apos;s the same principle as the universal port: what matters is that both follow the standard, not who built them.&lt;/p&gt;
&lt;h2&gt;What was released&lt;/h2&gt;
&lt;p&gt;At the announcement, MCP didn&apos;t arrive as a mere idea on paper, but with concrete and open material:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;The &lt;strong&gt;specification&lt;/strong&gt; of the standard and several &lt;strong&gt;SDKs&lt;/strong&gt; (software development kits, the tools for building clients and servers), published on GitHub and available to everyone.&lt;/li&gt;
&lt;li&gt;Support for &lt;strong&gt;local&lt;/strong&gt; MCP servers inside the Claude desktop app, so you can try connections on your own device.&lt;/li&gt;
&lt;li&gt;An &lt;strong&gt;open-source&lt;/strong&gt; collection of ready-made servers for common tools, including Google Drive, Slack, GitHub, Git, and Postgres. They serve as examples and starting points, instead of making everyone begin from scratch.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Anthropic also pointed to some early adopters, such as the companies Block and Apollo, and developer tools - among them Zed, Replit, Codeium, and Sourcegraph - working to integrate the standard into their products; support has since broadened to more recent tools too, such as &lt;a href=&quot;/en/changelog/gemini-cli&quot;&gt;Gemini CLI&lt;/a&gt;. One detail that isn&apos;t minor: MCP was presented as an open, collaborative project, not as a closed technology controlled by a single vendor.&lt;/p&gt;
&lt;h2&gt;Why a standard matters&lt;/h2&gt;
&lt;p&gt;The value of MCP isn&apos;t in a single feature, but in the shift of work it makes possible. Without a standard, whoever builds an assistant has to create a different connection for every tool; and whoever builds a tool has to redo the work for every assistant. With a standard, each side implements it &lt;strong&gt;only once&lt;/strong&gt;: whoever creates a tool writes a single MCP server and makes it usable by any compatible assistant; whoever creates an assistant adds MCP support and gains access to every existing server. Build once, connect everywhere.&lt;/p&gt;
&lt;p&gt;There are two more reasons this matters, even for people who don&apos;t write code. The first is &lt;strong&gt;less lock-in to a single vendor&lt;/strong&gt;: if the way to connect data and tools is common, it&apos;s easier to switch assistants or run several side by side, without redoing all the integrations. The second is &lt;strong&gt;transparency&lt;/strong&gt;: being an open standard, anyone can read the specification, understand how it works, and contribute, instead of having to trust a closed mechanism.&lt;/p&gt;
&lt;h2&gt;Cautions and status at launch&lt;/h2&gt;
&lt;p&gt;Honesty first: at the time of the announcement this was an initial release. Support for local servers was there from day one, while for remote and production use - connections that don&apos;t run only on one person&apos;s computer, but inside business systems - Anthropic pointed to tools still &quot;coming soon.&quot; As with any standard, moreover, the real value depends on adoption: a standard is useful if many people use it, and that shows over time, not on the first day, a path that continued when &lt;a href=&quot;/en/changelog/mcp-linux-foundation&quot;&gt;MCP moved under the Linux Foundation&lt;/a&gt; to strengthen its neutral governance.&lt;/p&gt;
&lt;p&gt;There&apos;s also a &lt;strong&gt;security&lt;/strong&gt; aspect to keep in mind. An MCP server gives an assistant access to data and, often, the ability to take actions. It should therefore be treated with the same care as any integration that touches real information: it&apos;s wise to know what it exposes, with what permissions, and to whom, perhaps delegating access with a fine-grained model like &lt;a href=&quot;/en/changelog/cloudflare-oauth-self-managed&quot;&gt;self-managed OAuth&lt;/a&gt; instead of a token that opens everything. The convenience of a uniform connection doesn&apos;t remove the responsibility to control it, for instance by running the less trusted servers in &lt;a href=&quot;/en/changelog/cloudflare-workers-containers&quot;&gt;isolated environments such as containers&lt;/a&gt;.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;The Model Context Protocol is an open standard, introduced by Anthropic on November 25, 2024, for connecting AI assistants to data and tools in a uniform way. It solves a concrete problem: the thicket of hand-built integrations, one for every combination of assistant and service. The idea, as with the USB standard, is to have a single common &quot;port&quot; in place of many different connections. It started with an open specification, SDKs, and examples, and with a few early adopters. Whether and how far it becomes a real reference standard will be told by adoption and the months ahead; the goal, though, is clear and sensible: less repeated work, more freedom of choice.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to bring MCP into your company&apos;s workflows?&quot; text=&quot;We build custom MCP servers and integrations to connect AI to your Laravel systems and business data, with permissions defined and kept under control.&quot; button=&quot;Let&apos;s build your MCP server →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://www.anthropic.com/news/model-context-protocol&quot;&gt;Introducing the Model Context Protocol - Anthropic&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://modelcontextprotocol.io/introduction&quot;&gt;What is the Model Context Protocol (MCP)? - modelcontextprotocol.io&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>CSS Anchor Positioning: place tooltips and menus without JavaScript</title><link>https://initd.it/en/changelog/css-anchor-positioning</link><guid isPermaLink="true">https://initd.it/en/changelog/css-anchor-positioning</guid><description>A new CSS feature lets you natively tether one element to another, like a tooltip to its button. What it is, the problem it solves, and why it cuts the reliance on JavaScript libraries.</description><pubDate>Tue, 28 May 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;A small box that pops up next to the right button to explain what it does (a &quot;tooltip&quot;, meaning a hint that appears on demand). A menu that opens right below the item that called it. An info card pinned to an icon. These are trivial to picture, yet surprisingly awkward to build well on a web page. The reason is that for years the browser had no direct way to say &quot;place this element next to that one.&quot; In May 2024 something arrived that tackles exactly this problem: CSS Anchor Positioning, a feature that lets you tether one element to another using only CSS, the language that defines how pages look, without reaching for JavaScript.&lt;/p&gt;
&lt;h2&gt;The news in brief&lt;/h2&gt;
&lt;p&gt;The feature landed in stable form with Google Chrome 125, released on 14 May 2024, and with Microsoft Edge, which shares the same rendering engine (Chromium). At the time of the announcement, Firefox and Safari don&apos;t support it yet; their teams are working on it. On top of that, the specification is still a draft from the W3C&apos;s CSS Working Group, the body that defines web standards, so some details could change. In practice this is a new feature, available for now in a single browser engine. That&apos;s an important thing to keep in mind before adopting it on a production site.&lt;/p&gt;
&lt;h2&gt;The problem: putting one element next to another&lt;/h2&gt;
&lt;p&gt;To see why the news matters, it helps to step back. An element like a tooltip is usually &quot;pulled&quot; out of the normal page flow (with the CSS property &lt;code&gt;position: absolute&lt;/code&gt;) and placed using coordinates. The catch is that the element has no idea where the button it should sit next to actually is. And the button&apos;s position keeps changing: when the page scrolls, when the window is resized, when the surrounding text grows.&lt;/p&gt;
&lt;p&gt;The answer, until now, was JavaScript, the programming language that runs in the browser. You needed code to measure the button&apos;s position, work out the tooltip&apos;s coordinates, and repeat that calculation on every scroll or resize. To avoid rewriting this logic each time, developers reach for specialized libraries such as Floating UI (the successor to Popper), built precisely to handle these calculations and the edge cases, like flipping the tooltip above the button when there&apos;s no room below. These are capable tools, but they come at a cost: extra code to load and maintain, and calculations that, running on every scroll, can weigh the page down and hurt the responsiveness measured by metrics like &lt;a href=&quot;/en/changelog/inp-core-web-vital&quot;&gt;INP&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Is your frontend still shipping JS libraries just to position tooltips and menus?&quot; text=&quot;We check whether you can already replace them with native CSS, or whether you need a fallback for browsers that don&apos;t support it yet.&quot; button=&quot;Assess your interface →&quot;}&lt;/p&gt;
&lt;h2&gt;What anchor positioning does&lt;/h2&gt;
&lt;p&gt;Anchor positioning moves this work into the browser, in the same vein as other features that bring into the engine capabilities that used to rely on external code, like the &lt;a href=&quot;/en/changelog/browser-ai-prompt-api&quot;&gt;Prompt API for AI&lt;/a&gt;. The idea is to declare the relationship directly in CSS: one element is marked as an &quot;anchor&quot;, another is positioned relative to it. From then on, the browser keeps them tied together and recomputes the position on its own whenever something moves or the page scrolls. Because the feature is built into the engine, this recalculation happens efficiently, without the extra code that used to run on every event.&lt;/p&gt;
&lt;h2&gt;How it works, in practice&lt;/h2&gt;
&lt;p&gt;The mechanism rests on a few ingredients. First you give the anchor a name with the &lt;code&gt;anchor-name&lt;/code&gt; property. Then, on the element you want to place, you use &lt;code&gt;position-anchor&lt;/code&gt; to point at that name and the &lt;code&gt;anchor()&lt;/code&gt; function to align its edges to the anchor&apos;s edges.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;/* the button becomes an anchor, with a name we choose */
.button {
  anchor-name: --info;
}

/* the tooltip is tethered to that anchor and placed just above it */
.tooltip {
  position: absolute;
  position-anchor: --info;
  bottom: anchor(top);          /* the tooltip&apos;s bottom edge meets the anchor&apos;s top edge */
  justify-self: anchor-center;  /* centered horizontally against the button */
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The line &lt;code&gt;bottom: anchor(top)&lt;/code&gt; reads like this: &quot;put the tooltip&apos;s bottom edge at the level of the anchor&apos;s top edge&quot;, meaning place it above the button. By changing these references you move the element above, below, or to the side, never spelling out absolute coordinates and never writing a line of JavaScript.&lt;/p&gt;
&lt;h2&gt;When there&apos;s no room&lt;/h2&gt;
&lt;p&gt;The most interesting case is the very one that makes hand-rolled positioning tedious: what happens if the tooltip, placed above the button, ends up off-screen because the button is near the top edge? Here anchor positioning offers a built-in fallback mechanism. Through a dedicated rule (&lt;code&gt;@position-try&lt;/code&gt;) you can list alternative positions, and the browser picks the first one that fits without being clipped. It&apos;s the same &quot;smart&quot; behavior that used to require libraries, achieved with CSS alone. There&apos;s also a way to hide the element when the anchor scrolls out of view, so a tooltip doesn&apos;t hang there over nothing.&lt;/p&gt;
&lt;h2&gt;What changes compared to JavaScript libraries&lt;/h2&gt;
&lt;p&gt;For anyone building interfaces, the main upside is less code to write and maintain. For common cases - tooltips, menus, small pop-up panels - you no longer need to add a dedicated library just to place one element next to another. The browser knows where the elements are and updates everything itself, more consistently from one site to the next.&lt;/p&gt;
&lt;p&gt;This doesn&apos;t retire the libraries. They stay useful for complex scenarios, for animations and special behaviors, and above all for guaranteeing the same result today, across every browser, including the ones that don&apos;t support the native feature yet. The choice, in short, depends on the project.&lt;/p&gt;
&lt;h2&gt;Availability and caveats&lt;/h2&gt;
&lt;p&gt;Since this is a new feature and, for now, present in a single engine, it&apos;s wise to adopt it with a progressive enhancement approach: build the interface so it stays usable even where the feature is missing, treating native anchoring as a bonus where it&apos;s available. Alternatively, you can keep using a library as a fallback and switch on the native method only in browsers that know it. Anchor positioning pairs well with the Popover API, another recent feature meant for showing overlaid panels such as menus and small windows, and with &lt;a href=&quot;/en/changelog/view-transitions-baseline&quot;&gt;View Transitions&lt;/a&gt; for animating state changes: together they cover much of what these layered interfaces need.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;CSS Anchor Positioning lets you tether one element to another directly in CSS, handing the position calculation to the browser. It arrived in stable form with Chrome 125 in May 2024, while the other browsers are still implementing it, and the specification is still a draft. For frontend work it means less JavaScript and fewer dependencies for a very common task, bearing in mind that support isn&apos;t universal yet. It&apos;s one of those pieces that, over time, shift into the browser jobs that used to fall on the people writing the code.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to lighten up your application&apos;s frontend?&quot; text=&quot;We build Vue and Laravel interfaces leaning on native browser features where possible, cutting JavaScript dependencies and load times.&quot; button=&quot;Let&apos;s talk frontend →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.chrome.com/blog/anchor-positioning-api&quot;&gt;Introducing the CSS anchor positioning API - Chrome for Developers&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_anchor_positioning&quot;&gt;CSS anchor positioning - MDN&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developer.chrome.com/release-notes/125&quot;&gt;Chrome 125 release notes - Chrome for Developers&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>Chrome Turns On Post-Quantum Encryption in TLS by Default: What Changes and What Can Break</title><link>https://initd.it/en/changelog/chrome-post-quantum-tls</link><guid isPermaLink="true">https://initd.it/en/changelog/chrome-post-quantum-tls</guid><description>Chrome enables hybrid post-quantum key exchange by default on desktop. Why it matters, what &apos;harvest now, decrypt later&apos; means, and why some network gear breaks.</description><pubDate>Thu, 16 May 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;For a few versions now, the Chrome browser has been protecting secure connections with a new piece of cryptography, designed to resist future quantum computers. It&apos;s on by default, so most people don&apos;t have to do anything and won&apos;t notice a thing. For anyone who runs servers and networks, though, there&apos;s an important detail: this change has surfaced latent bugs in some poorly implemented network devices, which means a few connections stop working after the browser updates. It&apos;s worth understanding what changed, why, and what to check.&lt;/p&gt;
&lt;h2&gt;The news in brief&lt;/h2&gt;
&lt;p&gt;Chrome enabled a &quot;hybrid&quot; quantum-resistant key exchange by default on desktop computers starting with version 124, released in spring 2024. Key exchange is the first step of every secure connection: the moment when the browser and the site agree on a shared secret key, which is then used to encrypt the rest of the conversation. All of this happens inside &lt;strong&gt;TLS&lt;/strong&gt;, the protocol behind &lt;code&gt;https&lt;/code&gt; and the padlock in the address bar.&lt;/p&gt;
&lt;p&gt;The change needs nothing from the user: if the site supports it, the connection starts out protected; if it doesn&apos;t, the old method is used. No one has to install or configure anything.&lt;/p&gt;
&lt;h2&gt;The threat it addresses: &quot;harvest now, decrypt later&quot;&lt;/h2&gt;
&lt;p&gt;To see why this matters, start with a threat that has an unsettling name: &lt;strong&gt;harvest now, decrypt later&lt;/strong&gt;. The idea is simple and unpleasant. Today, traffic on the Internet is encrypted: the data travelling between your device and the site is made unreadable to anyone who intercepts it, and that protection holds because current computers don&apos;t have the power to break it in any reasonable time.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Quantum computers&lt;/strong&gt; - a still-developing technology based on principles different from ordinary computers - could one day break much of the cryptography we use now. Nobody knows for sure whether or when that will happen. The problem, however, is already here: whoever intercepts encrypted traffic today can record and archive it, waiting to decrypt it later. Data that stays sensitive for many years - medical records, trade secrets, confidential communications - is therefore at risk right now, even though the machine capable of opening it doesn&apos;t yet exist. Securing key exchange is exactly what takes the value out of that pre-emptive harvesting.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Can your network handle a heavier ClientHello?&quot; text=&quot;We check firewalls, proxies and load balancers to see if they&apos;re ready for post-quantum key exchange before they break on their own.&quot; button=&quot;Check your network →&quot;}&lt;/p&gt;
&lt;h2&gt;How it works: a hybrid key exchange&lt;/h2&gt;
&lt;p&gt;In practice, the old cryptography wasn&apos;t thrown away and replaced with the new one. A &lt;strong&gt;hybrid&lt;/strong&gt; approach is used: a classic, battle-tested algorithm is combined with a post-quantum one. The connection stays protected as long as at least one of the two holds. So if a weakness were found in the new algorithm - not impossible, since it&apos;s recent - the traditional one would still protect you; and the other way around, the new part protects against a quantum attack. Belt and braces.&lt;/p&gt;
&lt;p&gt;The scheme Chrome turned on is called &lt;strong&gt;X25519Kyber768&lt;/strong&gt;. The name is a mouthful, but it says what&apos;s inside: &lt;em&gt;X25519&lt;/em&gt; is the classic algorithm used for years for key exchange, while &lt;em&gt;Kyber768&lt;/em&gt; is the post-quantum part. At the time of the announcement, Kyber was still a draft of the standard later published by the US agency NIST under the name &lt;strong&gt;ML-KEM&lt;/strong&gt;, the same agency that later picked &lt;a href=&quot;/en/changelog/nist-hqc-post-quantum&quot;&gt;HQC as a backup algorithm&lt;/a&gt; so as not to depend on a single mathematical approach. So it isn&apos;t one vendor&apos;s experiment, but an algorithm the industry is converging on. In later Chrome versions the scheme was updated to the finalized standard.&lt;/p&gt;
&lt;h2&gt;The side effect: the ClientHello gets bigger&lt;/h2&gt;
&lt;p&gt;Here&apos;s the part that concerns sysadmins directly. The post-quantum key takes up much more space than the classic one. This inflates the &lt;strong&gt;ClientHello&lt;/strong&gt;, the first message the browser sends to introduce itself to the server at the start of the connection. In that message, the browser lists what it can do, including the keys it offers for the exchange, the same envelope another recent extension, &lt;a href=&quot;/en/changelog/tls-encrypted-client-hello&quot;&gt;Encrypted Client Hello&lt;/a&gt;, tries to encrypt so eavesdroppers can&apos;t read its contents.&lt;/p&gt;
&lt;p&gt;With the post-quantum part added, this first message becomes large enough that it no longer fits in a single network packet, so it gets split into two. That isn&apos;t free: according to Google&apos;s announcement, the extra size adds roughly a 4% increase in median latency to all of Chrome&apos;s TLS handshakes on desktop. It&apos;s a small cost, but a real one, and it&apos;s one reason the change reached the desktop first, where connections are usually faster.&lt;/p&gt;
&lt;h2&gt;Why some devices break&lt;/h2&gt;
&lt;p&gt;The latency cost was expected. What wasn&apos;t expected is that turning this on by default exposed pre-existing bugs in several products that sit &quot;in the middle&quot; of connections. In the jargon these are called &lt;strong&gt;middleboxes&lt;/strong&gt;: firewalls, &lt;a href=&quot;/en/changelog/nginx-reverse-proxy&quot;&gt;proxies&lt;/a&gt;, load balancers, and especially &lt;strong&gt;TLS inspection&lt;/strong&gt; systems - devices that peek at or filter encrypted traffic in transit, very common on corporate networks.&lt;/p&gt;
&lt;p&gt;In theory, a change like this shouldn&apos;t break anything. TLS is designed to be extensible: if a device runs into an option it doesn&apos;t recognize, the rule is to ignore it and carry on with the ones it does. Offering post-quantum key exchange is therefore backwards-compatible, and standards-compliant systems keep working with no changes. The trouble is that not everything is standards-compliant. Some devices assumed the ClientHello would be small and arrive in a single packet, or handled unexpectedly sized messages poorly. As long as every ClientHello was small, the flaw stayed hidden. The moment the message grew and split across two packets, those devices started rejecting or truncating the connection.&lt;/p&gt;
&lt;p&gt;The point to keep in mind: this is not a bug in Chrome, nor in post-quantum cryptography. It&apos;s a pre-existing flaw in a network device that the change simply made visible. Google confirmed that the rollout revealed a number of such bugs in third-party products.&lt;/p&gt;
&lt;h2&gt;What server operators should check&lt;/h2&gt;
&lt;p&gt;The typical symptom is clear: after a Chrome update, some users can no longer reach a site or service, while a different browser or version works fine. If that happens, here&apos;s how to proceed.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Suspect the path, not the browser.&lt;/strong&gt; The problem is almost never the client or the final server, but something in between: a proxy, a firewall doing TLS inspection, a load balancer, a perimeter security appliance.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Isolate the cause.&lt;/strong&gt; Chrome provides an enterprise policy, &lt;code&gt;PostQuantumKeyAgreementEnabled&lt;/code&gt;, that lets you temporarily turn off post-quantum key exchange. If disabling it makes the problem go away, the diagnosis is confirmed: some device can&apos;t handle the larger ClientHello.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Patch the offending device.&lt;/strong&gt; The correct fix is to ask the vendor for an updated version that handles large messages properly. Disabling via policy is meant as a temporary workaround, to buy time for the fix, not as a permanent state.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Don&apos;t put it off.&lt;/strong&gt; Post-quantum key exchange isn&apos;t going away - it&apos;s becoming the norm, so much so that &lt;a href=&quot;/en/changelog/post-quantum-adoption&quot;&gt;more than half of global web traffic is already post-quantum encrypted&lt;/a&gt;. A device that breaks with Chrome today will break tomorrow with other browsers and updated clients. Better to fix it now.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;For most people there&apos;s nothing to do: keep the browser and operating system updated, and the protection arrives on its own. For anyone running infrastructure the message is twofold. On one hand it&apos;s good news, because traffic is starting to be protected against a concrete, if still future, threat. On the other it&apos;s a reminder: network gear that inspects or filters TLS needs to be kept updated and standards-compliant, because every evolution of the protocol, &lt;a href=&quot;/en/changelog/tls-certificates-47-days&quot;&gt;from ever-shorter certificate lifetimes&lt;/a&gt; to the cryptography of the key exchange itself, can expose shortcuts taken in the past. This is the first wave, not the last.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Got devices sitting in the middle of your connections that need updating?&quot; text=&quot;We manage servers, firewalls and corporate networks: we find the appliances that can&apos;t handle modern TLS and bring them up to standard before they stop working.&quot; button=&quot;Let&apos;s secure the network →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.google/chromium/advancing-our-amazing-bet-on-asymmetric/&quot;&gt;Advancing our amazing bet on asymmetric cryptography - Chromium Blog&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://chromeenterprise.google/policies/post-quantum-key-agreement-enabled/&quot;&gt;PostQuantumKeyAgreementEnabled - Chrome Enterprise policy&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item><item><title>INP Replaces FID in Core Web Vitals: What It Measures and What to Watch</title><link>https://initd.it/en/changelog/inp-core-web-vital</link><guid isPermaLink="true">https://initd.it/en/changelog/inp-core-web-vital</guid><description>As of March 12, 2024, Interaction to Next Paint (INP) replaces First Input Delay among Google&apos;s Core Web Vitals. What it measures, the good threshold under 200 ms, and why it matters for user experience and SEO.</description><pubDate>Tue, 12 Mar 2024 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;As of &lt;strong&gt;March 12, 2024&lt;/strong&gt;, one of the metrics Google uses to judge the quality of a web page changes. A metric called &lt;strong&gt;FID&lt;/strong&gt; is being retired and replaced by another one, &lt;strong&gt;INP&lt;/strong&gt;. The change concerns the &lt;strong&gt;Core Web Vitals&lt;/strong&gt;, the set of indicators that measure the experience of loading and using a site. This isn&apos;t a small, niche technical tweak: it touches both how a site feels to the people using it and how Google factors performance into ranking. So it&apos;s worth understanding what actually changes, in plain terms.&lt;/p&gt;
&lt;h2&gt;What Core Web Vitals are&lt;/h2&gt;
&lt;p&gt;The &lt;strong&gt;Core Web Vitals&lt;/strong&gt; are a small group of metrics Google uses to measure, with concrete numbers, how pleasant a page is to use. They don&apos;t judge the content or the design: they look at technical behavior. Historically there are three, each with a simple question behind it.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;LCP&lt;/strong&gt; (&lt;em&gt;Largest Contentful Paint&lt;/em&gt;): how long before the main content appears, which also depends on how fast &lt;a href=&quot;/en/changelog/ttfb-explained&quot;&gt;the server&apos;s first response&lt;/a&gt; is? Considered good under 2.5 seconds.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;CLS&lt;/strong&gt; (&lt;em&gt;Cumulative Layout Shift&lt;/em&gt;): how much do elements &quot;jump&quot; while the page loads? Considered good under 0.1.&lt;/li&gt;
&lt;li&gt;The third one is about &lt;strong&gt;responsiveness&lt;/strong&gt;, meaning how quickly the page reacts when you tap or click something. This is the one that changes.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Until March 2024, responsiveness was measured with &lt;strong&gt;FID&lt;/strong&gt; (&lt;em&gt;First Input Delay&lt;/em&gt;). From that date it&apos;s measured with &lt;strong&gt;INP&lt;/strong&gt; (&lt;em&gt;Interaction to Next Paint&lt;/em&gt;).&lt;/p&gt;
&lt;h2&gt;What INP is and what it measures&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;INP&lt;/strong&gt; stands for &lt;em&gt;Interaction to Next Paint&lt;/em&gt;. It measures something everyone has felt without having a name for it: that small delay between the moment you click a button, open a menu, or tick a checkbox, and the moment the screen shows that &lt;em&gt;something happened&lt;/em&gt;.&lt;/p&gt;
&lt;p&gt;When that delay is short, the site feels ready and alive. When it&apos;s long, you&apos;re left with the feeling of having pressed nothing: you&apos;re tempted to click again, and the page seems stuck or broken, even when it isn&apos;t.&lt;/p&gt;
&lt;p&gt;According to web.dev&apos;s documentation, the time of an interaction breaks down into three parts:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;the &lt;strong&gt;input delay&lt;/strong&gt;, the time before the browser starts running the code tied to the interaction (often because it&apos;s busy with something else);&lt;/li&gt;
&lt;li&gt;the &lt;strong&gt;processing time&lt;/strong&gt;, how long the code takes to do its work in response to the click;&lt;/li&gt;
&lt;li&gt;the &lt;strong&gt;presentation delay&lt;/strong&gt;, the time it then takes to draw the updated result on the screen.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;INP accounts for all three parts. What counts as an interaction is &lt;strong&gt;mouse clicks&lt;/strong&gt;, &lt;strong&gt;taps on a touchscreen&lt;/strong&gt;, and &lt;strong&gt;key presses&lt;/strong&gt;; scrolling and simply hovering the pointer over an element do not count.&lt;/p&gt;
&lt;p&gt;::cta{variant=&quot;inline&quot; title=&quot;Does your site respond right away, or can users feel that small delay after every click?&quot; text=&quot;We measure your site&apos;s real INP with field data and pinpoint where the browser is losing time.&quot; button=&quot;Ask for a measurement →&quot;}&lt;/p&gt;
&lt;h2&gt;What changes compared to FID&lt;/h2&gt;
&lt;p&gt;The old FID measured only the &lt;strong&gt;input delay of the first interaction&lt;/strong&gt; of the visit. It had two important limits. First: it looked only at the first tap, so if the first click was fast but every later one was slow, the score stayed good while failing to reflect the real experience. Second: it measured only the initial wait, ignoring how long the code then took to respond and to show the result.&lt;/p&gt;
&lt;p&gt;INP fixes both points. It observes &lt;strong&gt;all&lt;/strong&gt; interactions during the entire visit, not just the first, and it considers the whole path, from the click to when the screen updates. The reported value is close to the slowest interaction observed (setting aside rare, isolated cases), so it represents the worst experience the user actually ran into, not the best one. In practice it&apos;s a more honest measure, and harder to make &quot;look good&quot; by chance.&lt;/p&gt;
&lt;h2&gt;The threshold: good under 200 ms&lt;/h2&gt;
&lt;p&gt;The practical reference is simple. web.dev&apos;s documentation gives three bands:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;good&lt;/strong&gt;: INP at or below &lt;strong&gt;200 milliseconds&lt;/strong&gt;;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;needs improvement&lt;/strong&gt;: between 200 and 500 milliseconds;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;poor&lt;/strong&gt;: above &lt;strong&gt;500 milliseconds&lt;/strong&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A millisecond is a thousandth of a second, so 200 ms is a fifth of a second: the line that separates a page that feels responsive from one that starts to feel sluggish.&lt;/p&gt;
&lt;p&gt;One important detail about how the value is read: you don&apos;t look at the luckiest user, but at the &lt;strong&gt;75th percentile&lt;/strong&gt; of real visits, measured separately for mobile and desktop devices. Put simply, to be considered good a site has to respond under 200 ms for at least 75% of visits. It&apos;s a way to keep problems from hiding behind an average: what matters is that the experience is good for the large majority, not just in ideal conditions.&lt;/p&gt;
&lt;h2&gt;Why it matters for SEO, and the timeline of the change&lt;/h2&gt;
&lt;p&gt;Core Web Vitals aren&apos;t just about tidiness: they&apos;re one of the factors Google considers for page experience, and so they can influence ranking in search results. They aren&apos;t the only nor the most important criterion, but with equal content a responsive site starts ahead of one that reacts late. The link with SEO is therefore indirect but real, and it runs mostly through the experience offered to the people who actually visit the site.&lt;/p&gt;
&lt;p&gt;On the practical side, the switch has already happened: as of March 12, 2024, INP is fully a Core Web Vital and FID no longer is. Google announced the change well in advance, in May 2023, and the metric had been available in experimental form even before that. Retiring FID is gradual across tooling: it was removed right away from the main Search Console report, while other tools set a transition period to give developers time to adjust. Anyone who was watching FID simply needs to shift their attention to INP.&lt;/p&gt;
&lt;h2&gt;How to keep it in check and improve it&lt;/h2&gt;
&lt;p&gt;The first useful thing is to &lt;strong&gt;measure with real data&lt;/strong&gt;. INP is best assessed in the field, meaning on actual visits, not just in the lab: tools like Search Console (in the Core Web Vitals report), PageSpeed Insights, and Chrome&apos;s CrUX data show the value collected from real users, on their devices and their connections.&lt;/p&gt;
&lt;p&gt;As for causes, a high INP usually means the user&apos;s device is too busy running code to respond quickly to interactions. The general levers follow from that, and they act mostly on the browser side.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Lighten the browser&apos;s workload.&lt;/strong&gt; The less code runs in response to a click, the sooner the screen can update. Cutting the unnecessary work triggered by every interaction, for instance by handing positioning that&apos;s now done with custom scripts over to &lt;a href=&quot;/en/changelog/css-anchor-positioning&quot;&gt;native CSS anchoring&lt;/a&gt;, is often the most effective step.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Break up long tasks.&lt;/strong&gt; A heavy, uninterrupted task keeps the browser busy and blocks responses. Splitting it into smaller pieces leaves room to handle interactions between one chunk and the next.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Rein in third-party scripts and widgets.&lt;/strong&gt; External trackers and tools add work that isn&apos;t always visible but weighs on responsiveness. It&apos;s worth checking their real cost: on &lt;a href=&quot;/en/changelog/speed-up-prestashop&quot;&gt;a store packed with modules&lt;/a&gt; it&apos;s often the first place to look.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Prioritize what the user sees and touches.&lt;/strong&gt; Deferring non-urgent activity, so that immediate interactions take precedence, helps keep the perceived delay low.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;As always in these cases, it pays to measure before and after each change: responsiveness depends on many factors, and the right approach is to understand &lt;em&gt;where&lt;/em&gt; the browser loses time instead of changing everything at random.&lt;/p&gt;
&lt;h2&gt;In short&lt;/h2&gt;
&lt;p&gt;As of March 12, 2024, a page&apos;s responsiveness is measured with &lt;strong&gt;INP&lt;/strong&gt; instead of FID. INP looks at all the interactions in a visit and considers the whole path from click to visible result, giving a more realistic picture of how the site responds. The threshold to keep in mind is &lt;strong&gt;200 milliseconds&lt;/strong&gt; for at least 75% of visits. It matters for two reasons that hold together: a more responsive site is more pleasant to use and, in turn, starts with a slight advantage on the SEO side too. The starting point stays the same: measure with real data, find where the delay comes from, and act on the right layer.&lt;/p&gt;
&lt;p&gt;::cta{title=&quot;Want to bring your INP under 200 milliseconds?&quot; text=&quot;We work on third-party scripts, client-side code and server configuration to make your site responsive, from the first byte to the single interaction.&quot; button=&quot;Let&apos;s talk →&quot;}&lt;/p&gt;
&lt;h2&gt;Sources&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/blog/inp-cwv-launch&quot;&gt;Interaction to Next Paint becomes a Core Web Vital on March 12 - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/articles/inp&quot;&gt;Interaction to Next Paint (INP) - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://developers.google.com/search/blog/2023/05/introducing-inp&quot;&gt;Introducing INP to Core Web Vitals - Google Search Central&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://web.dev/articles/vitals&quot;&gt;Web Vitals - web.dev&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded><author>Alessandro Corbelli</author></item></channel></rss>