IPv6 and IoT News Archives - IPv6.net https://ipv6.net/c/news/ The IPv6 and IoT Resources Fri, 20 Nov 2026 19:37:05 +0000 en-US hourly 1 https://wordpress.org/?v=7.1.5 Qualcomm and Arduino partner with Walt Disney Imagineering and REV Robotics to take the FIRST K-8 experience into the future  https://ipv6.net/news/qualcomm-and-arduino-partner-with-walt-disney-imagineering-and-rev-robotics-to-take-the-first-k-8-experience-into-the-future/ Fri, 20 Nov 2026 19:37:05 +0000 https://ipv6.net/?p=2927350 The new program will be powered by the Arduino® platform with Walt Disney Imagineers helping bring annual game themes to life. FIRST is developing its next generation of K-8 robotics programs for the 2027–2028 season, welcoming Qualcomm Technologies as lead technology partner and the Arduino development ecosystem to power the new platform. It marks a […]

The post Qualcomm and Arduino partner with Walt Disney Imagineering and REV Robotics to take the FIRST K-8 experience into the future  appeared first on IPv6.net.

]]>

The new program will be powered by the Arduino® platform with Walt Disney Imagineers helping bring annual game themes to life.

FIRST is developing its next generation of K-8 robotics programs for the 2027–2028 season, welcoming Qualcomm Technologies as lead technology partner and the Arduino development ecosystem to power the new platform.

It marks a major new chapter for FIRST as its nearly three-decade FIRST® LEGO® League collaboration concludes and evolves into a new era of hands-on STEM, giving students an early look at how real-world engineers work.

Arduino’s role is to help make first builds approachable and give students room to take on more advanced coding, sensing, and prototyping as their skills grow. 

FIRST has a presence in more than 100 countries and reached over 850,000 young people in the 2025–2026 season. Its influence extends well beyond robotics competitions, though. In FIRST’s 10-year study, 83% of alumni pursued STEM majors by their fourth year of college, and 63% were employed in STEM fields. The new K-8 program builds on that track record by giving students an early opportunity to see what engineering looks like when they’re the ones designing, building, and testing a solution.

How FIRST and Arduino are bringing hands-on engineering to a new generation of robotics teams

In the new FIRST K-8 robotics program, students will work in teams to turn ideas into working prototypes. They’ll decide how to tackle a challenge, build a robot, test their approach, and use what they observe to improve the design. If the robot doesn’t behave as intended, the team has a decision to make. Do they change the code, adjust the build, or run another test to see if the problem will happen again? They’ll have to explain what they saw, weigh each other’s ideas, and agree on what to try next. The new hardware options for grades 3-8 are built on the Arduino® UNO™ Q board.

“Every great innovation starts with curiosity. When students are given the right tools, supportive mentors, and the freedom to explore, incredible things happen. Through this collaboration with FIRST and Qualcomm Technologies, we are helping students move from imagination to creation, building the technical skills, creativity, and resilience they will need to shape the future,” said Fabio Violante, Vice President and General Manager of Arduino at Qualcomm Europe.

What it takes to build a new robotics program

A robotics challenge starts with a problem worth solving. What should the robot do? What will make that task interesting enough for a team to try again when its first design falls short? Walt Disney Imagineering is working with FIRST to help develop the games, challenges, and annual themes that give teams a reason to build in the first place.

REV Robotics will design and manufacture the physical build system students will use to turn ideas into working robots.

Helping educators get a team off the ground

For a teacher or coach starting a robotics team, the first question may be as simple as, “What do we do at our first meeting?” FIRST is designing the program for educators and coaches with a range of robotics experience. Planned professional development and resources such as team meeting guides will help get students building with support as they work through their first challenges.

What’s next for FIRST K-8 robotics

The new programs are set to launch in spring 2027. FIRST will share more information ahead of the 2027–2028 season, including the program names, details about the games and technology platform, educator resources, and how to participate. 

Sign up for the FIRST K-8 updates to hear when those details are announced and to find answers to frequently asked questions.

Arduino and UNO are trademarks or registered trademarks of Arduino S.r.l.

The post Qualcomm and Arduino partner with Walt Disney Imagineering and REV Robotics to take the FIRST K-8 experience into the future  appeared first on Arduino Blog.

Read more here: https://blog.arduino.cc/2026/11/20/qualcomm-and-arduino-partner-with-walt-disney-imagineering-and-rev-robotics-to-take-the-first-k-8-experience-into-the-future/

The post Qualcomm and Arduino partner with Walt Disney Imagineering and REV Robotics to take the FIRST K-8 experience into the future  appeared first on IPv6.net.

]]>
How a world champion motorboat racer built his own electronics using Arduino https://ipv6.net/news/how-a-world-champion-motorboat-racer-built-his-own-electronics-using-arduino/ Fri, 20 Nov 2026 13:37:06 +0000 https://ipv6.net/?p=2927327 Luca Finotti is a 2023 F125 world champion, an industrial automation engineering student, and a professional PLC programmer. He is also, in his own words, “someone who likes to build devices of all kinds using Arduino” – and who decided there was no reason to keep that hobby separate from his racing career. The result […]

The post How a world champion motorboat racer built his own electronics using Arduino appeared first on IPv6.net.

]]>

Luca Finotti is a 2023 F125 world champion, an industrial automation engineering student, and a professional PLC programmer. He is also, in his own words, “someone who likes to build devices of all kinds using Arduino” – and who decided there was no reason to keep that hobby separate from his racing career.

The result is a collection of custom-built electronics that, according to Finotti, have supported his performance on the water. Not because the rulebook required it, but because he saw an opportunity and went after it.

From spectator to competitor – and then to engineer

Finotti came to motorboat racing through his father, who started taking him to motorsport events when he was just two years old. He took part in his first competition in 2016, after the Italian Motorboat Federation opened a test day to the public: he couldn’t resist signing up! From there, he focused not only on speed, but also on better understanding his boat’s performance.

“I started creating projects for use in competitions because I believe electronics can give you an extra edge,” Finotti explains. “In Formula 1 and MotoGP, electronics have become fundamental. I wanted to try to create devices that could give me advantages, assistance, and supervision of on-board systems.” The categories he competes in are relatively bare from an electronics standpoint, and regulations are simple enough to leave plenty of room to experiment.

The device Finotti used during his world-title season

His first Arduino project was a thermocouple selector: a simple tool to switch between exhaust temperature and cooling water temperature readings at the press of a button, solving a problem his instrumentation couldn’t handle and his budget couldn’t fix with an off-the-shelf solution. But the project that made the biggest difference was the one he built around air density.

Air density is one factor in engine carburetion. An improper carburetion setting can affect engine performance and may increase the risk of engine damage. Finotti custom built an air density meter that gives him an immediate reference point for how to set up the carburetion before heading out on the water, which, according to Finotti, helps him select a carburetion setup before going on the water and may save time during free practice and qualifying.

Alongside that, he developed an in-race carburetion variator. In his category, carburetion can only be adjusted when the boat is stationary at the starting pontoon. Once on the water, there’s no way to change anything. Finotti’s device – built with buttons, a display, and a stepper motor – changes that. It allows fine adjustments to carburetion even while driving.

Finotti says he used that device during the final round of his 2023 world-championship season. “In the last round of the world championship, I had decided to go with a conservative setup to avoid engine failure and not risk losing the title,” he says. “But this conservative approach turned out to be a disadvantage, so I was able to vary the carburetion while racing and shift the engine to a more aggressive setup to recover positions. Then, by reconfiguring the carburetion, I managed to reduce the risk, finish the race in first position, and win the world title.” His 2025 season confirmed the approach: he claimed the Italian championship title, took third on the European podium, and finished runner-up at the world level, all in the F125 class.

Engineering on the water: humidity, vibration, and resin printing

Building electronics for motorboat racing is not the same as building for the bench. Humidity and vibration are constant enemies, and a device that works in the workshop may perform differently at racing speed on the water. Finotti’s solution has evolved alongside his skills: in recent years he’s added resin 3D printing to his toolkit, combined with the CAD modeling he’s learned through his engineering studies. Custom enclosures, vibration dampers, and purpose-built mounts are now part of every project.

His most-used boards are a simple Arduino® Nano™ for compact, low-I/O applications and Arduino® UNO™ board for bench development – choices driven by size constraints as much as functionality. Every gram matters on a racing hull.

What’s next

Finotti’s current projects are ambitious. He’s developing a test bench that has PLC and Arduino working together to simulate and collect engine data in the workshop – a setup intended to let him evaluate certain modifications in the workshop before testing them on the water, which may reduce some on-water testing. He’s also working on an airflow variator with a mass flow meter, capable of opening additional air intakes in the hull and compensating with extra fuel injection to maintain the correct air-fuel ratio. And further down the line: his own custom ECU to replace the carburetor system entirely with injection, controlled by electronics of his own design.

His advice for athletes who don’t have his technical background but want to start using Arduino in their own sport is direct: “Electronics is the future and it’s within everyone’s reach. It’s a world so vast that it allows you to find a solution to any problem. Don’t give up, and believe in every project to the end. Failure is normal. But a failure will always remain one if you give up at the first difficulty. The satisfaction of seeing something work that previously existed only in your imagination is something extraordinary.”

We’ll be following Finotti on Instagram and TikTok to keep up with his progress!

Arduino, Nano, and UNO are trademarks or registered trademarks of Arduino S.r.l.

The post How a world champion motorboat racer built his own electronics using Arduino appeared first on Arduino Blog.

Read more here: https://blog.arduino.cc/2026/11/20/how-a-world-champion-motorboat-racer-built-his-own-electronics-using-arduino/

The post How a world champion motorboat racer built his own electronics using Arduino appeared first on IPv6.net.

]]>
GUITION ESP32-S31 development kit features 7-inch capacitive touch display, Ethernet port https://ipv6.net/news/guition-esp32-s31-development-kit-features-7-inch-capacitive-touch-display-ethernet-port/ Fri, 20 Nov 2026 11:07:06 +0000 https://ipv6.net/?p=2927319 After the Waveshare ESP32-S31-Touch-LCD-4.3C and VIEWE PLCM-UES31S043H800V480C-U, the GUITION JC1060F570C is another ESP32-S31 development kit with an integrated 7-inch touchscreen display. Some companies might reconsider the way they name their product… Leaving that aside, the GUITION devkit is especially interesting as it features a large 7-inch capacitive display compared to the 4.3-inch panels used in […]

The post GUITION ESP32-S31 development kit features 7-inch capacitive touch display, Ethernet port appeared first on IPv6.net.

]]>
ESP32-S31 devkit with 7-inch touch display Ethernet port

After the Waveshare ESP32-S31-Touch-LCD-4.3C and VIEWE PLCM-UES31S043H800V480C-U, the GUITION JC1060F570C is another ESP32-S31 development kit with an integrated 7-inch touchscreen display. Some companies might reconsider the way they name their product… Leaving that aside, the GUITION devkit is especially interesting as it features a large 7-inch capacitive display compared to the 4.3-inch panels used in the other two models, and it’s the first to make use of the native Ethernet interface from the ESP32-S31 SoC. GUITION JC1060F570C_I_W_Y specifications: Wireless module – ESP32-S31-WROOM-3-N16R16V SoC – ESP32-S31NRV16 CPU RISC-V HP (High-performance) RV32IMAFCP CPU @ 320 MHz with FPU, SIMD, etc. RISC-V LP (Low-power) MCU core Memory – 512 KB SRAM, 32 KB low-power SRAM, 16MB PSRAM Wireless – 2.4 GHz WiFi 6 (802.11ax) Bluetooth 5.4 with support for LE Audio, direction finding, Bluetooth Mesh 1.1, and Classic (BR/EDR) 802.15.4 radio for Zigbee, Thread, and Matter Storage – 16 MB flash Antenna – PCB […]

The post GUITION ESP32-S31 development kit features 7-inch capacitive touch display, Ethernet port appeared first on CNX Software – Embedded Systems News.

Read more here: https://www.cnx-software.com/2026/11/20/guition-esp32-s31-development-kit-features-7-inch-capacitive-touch-display-ethernet-port/

The post GUITION ESP32-S31 development kit features 7-inch capacitive touch display, Ethernet port appeared first on IPv6.net.

]]>
M5Stack Chain Captain – An ESP32-S3 multifunctional controller with 1.54-inch color display, audio, motion sensing, IR Tx/Rx https://ipv6.net/news/m5stack-chain-captain-an-esp32-s3-multifunctional-controller-with-1-54-inch-color-display-audio-motion-sensing-ir-tx-rx/ Fri, 20 Nov 2026 08:37:06 +0000 https://ipv6.net/?p=2927304 M5Stack Chain Captain is an ESP32-S3-based multifunctional programmable controller that features a 1.4-inch color square display, a speaker and microphone for audio interaction, motion sensing, and infrared transmission and reception. The IoT controller features 16MB SPI flash and 8MB on-chip PSRAM, Chain and Grove 4-pin ports, a 15-pin GPIO header, and several buttons and RGB. […]

The post M5Stack Chain Captain – An ESP32-S3 multifunctional controller with 1.54-inch color display, audio, motion sensing, IR Tx/Rx appeared first on IPv6.net.

]]>
M5Stack Chain Captain

M5Stack Chain Captain is an ESP32-S3-based multifunctional programmable controller that features a 1.4-inch color square display, a speaker and microphone for audio interaction, motion sensing, and infrared transmission and reception. The IoT controller features 16MB SPI flash and 8MB on-chip PSRAM, Chain and Grove 4-pin ports, a 15-pin GPIO header, and several buttons and RGB. It’s powered by an 800 mAh battery that can be charged at 5V through USB-C or any of the expansion connectors. Chain Captain Dev Kit (ESP32-S3) specifications: SoC – Espressif ESP32-S3R8 CPU – Dual-core Tensilica LX7 microcontroller up to 240 MHz with vector instructions for AI acceleration Memory – 8MB PSRAM Wireless – WiFi 4 and Bluetooth 5.0 LE + Mesh connectivity Storage – 16MB SPI flash Display – 1.54-inch color LCD with 240 x 240 resolution; JD9853A SPI driver Audio ES8311 audio codec AW8737A amplifier 1W / 8Ω speaker MEMS microphone USB – USB […]

The post M5Stack Chain Captain – An ESP32-S3 multifunctional controller with 1.54-inch color display, audio, motion sensing, IR Tx/Rx appeared first on CNX Software – Embedded Systems News.

Read more here: https://www.cnx-software.com/2026/11/20/m5stack-chain-captain-an-esp32-s3-multifunctional-controller-with-1-54-inch-color-display-audio-motion-sensing-ir-tx-rx/

The post M5Stack Chain Captain – An ESP32-S3 multifunctional controller with 1.54-inch color display, audio, motion sensing, IR Tx/Rx appeared first on IPv6.net.

]]>
What small ISPs told me about IPv6 adoption https://ipv6.net/news/what-small-isps-told-me-about-ipv6-adoption/ Fri, 20 Nov 2026 05:07:05 +0000 https://ipv6.net/?p=2927296 Guest Post: Whenever I talked to small ISPs in Bangladesh, I asked them what was stopping them from deploying IPv6. Their answers surprised me. Read more here: https://blog.apnic.net/2026/11/20/what-small-isps-told-me-about-ipv6-adoption/

The post What small ISPs told me about IPv6 adoption appeared first on IPv6.net.

]]>
Guest Post: Whenever I talked to small ISPs in Bangladesh, I asked them what was stopping them from deploying IPv6. Their answers surprised me.

Read more here: https://blog.apnic.net/2026/11/20/what-small-isps-told-me-about-ipv6-adoption/

The post What small ISPs told me about IPv6 adoption appeared first on IPv6.net.

]]>
nginx2root: Five new nginx vulnerabilities, and how Cloudflare protects origins from the worst of them https://ipv6.net/news/nginx2root-five-new-nginx-vulnerabilities-and-how-cloudflare-protects-origins-from-the-worst-of-them/ Fri, 20 Nov 2026 02:07:05 +0000 https://ipv6.net/?p=2927291 On November 18, 2026, F5 and nginx.org disclosed ten vulnerabilities in nginx. Five of them, detailed by the Xint research team and published under the name nginx2root, are memory corruption flaws that an unauthenticated attacker can use to crash an nginx worker or, per Xint’s research, run commands on the server. Xint also found a […]

The post nginx2root: Five new nginx vulnerabilities, and how Cloudflare protects origins from the worst of them appeared first on IPv6.net.

]]>

On November 18, 2026, F5 and nginx.org disclosed ten vulnerabilities in nginx. Five of them, detailed by the Xint research team and published under the name nginx2root, are memory corruption flaws that an unauthenticated attacker can use to crash an nginx worker or, per Xint’s research, run commands on the server. Xint also found a Linux kernel bug that turns that foothold into root on the host, including from inside a Docker container. Other teams found the two HTTP/2 bugs independently: F5 also credits Rapid7, Wiz Research and Ikotas Labs for CVE-2026-123007, and Metnir, Wiz Research, and Palo Alto Networks Unit 42 for CVE-2026-123633.

nginx is an HTTP web server that also serves as reverse proxy, content cache, load balancer, TCP/UDP proxy server, and mail proxy server. nginx runs a large share of the world’s web servers, so this is a patch-now event. But if your nginx server is reachable only through Cloudflare’s proxy, attackers cannot reach the vulnerable code paths for the most serious of these bugs, giving you protection while you update your servers.

Here is where Cloudflare stands, what that protection covers, where it stops, and how the bugs work.

The short version

  • Cloudflare’s edge is not affected. Much of the proxy that handles customer traffic at our edge now runs on FL2, written in Rust. We reviewed the parts still built on our heavily modified nginx fork against all five bugs before disclosure, and an update closing the related code paths finished rolling out globally before the vulnerabilities were published. The same releases fix five other nginx CVEs, including CVE-2026-118899, an infinite loop while reading a request body over TLS 1.3.
  • Origins behind Cloudflare’s HTTP proxy are shielded from the HTTP/2 and HTTP/3 attacks. For proxied hostnames, Cloudflare terminates every client HTTP/2 and HTTP/3 connection at our edge and opens a separate connection to your origin. The attacker’s frames never reach your nginx.
  • The resolver and mail proxy vulnerabilities depend on specific configuration. Many configurations of nginx will not be vulnerable, but the safest way to be sure is to update your install or disable features.
  • You should still patch. Update to nginx 1.30.7 or 1.31.9 (or your vendor’s fixed build) and restart. Some configurations, covered below, are not protected by the proxy.

What was disclosed

nginx2root is five independent bugs. Each one works on its own and each one needs a different configuration.

CVE

Bug class

Affected configuration

First affected release

CVE-2026-123007

Integer overflow leading to out-of-bounds heap read/write

HTTP/2 enabled

1.9.5 (2015)

CVE-2026-123633

Use-after-free

HTTP/2 with proxy_pass to a backend, worker low on worker_connections

1.19.7

CVE-2026-121810

Use-after-free

HTTP/3 (QUIC) with proxy_pass to a backend

1.25.0

CVE-2026-123634

Use-after-free

resolver + proxy_pass with variables + a subrequest (mirror or SSI)

0.6.18

CVE-2026-113425

Use-after-free

Mail proxy with proxy on and auth_http

0.5.33

F5 rates each one High (CVSS 3.1: 8.1) and Critical (CVSS 4.0: 9.2), and notes that code execution requires disabling or bypassing ASLR (Address Space Layout Randomization). For CVE-2026-123007, Xint’s write-up shows how it leaked memory addresses to do exactly that.

CVE-2026-123007 is the one to worry about most. It only needs HTTP/2 turned on, which is commonly enabled on TLS deployments, and it has been in every nginx release since HTTP/2 support shipped in 1.9.5. Xint ran the exploit over the public Internet against servers on AWS, GCP and Azure. Xint searched Shodan on November 10, before the disclosure, and found 56.7 million hosts matching product:nginx. Of the 11.94 million that reported a version, 98.9% fell in the affected range. As of November 19, Censys’s nginx2root exposure tracker counts about 8.8 million services running a potentially affected version with HTTP/2 enabled. Version strings don’t prove a host is vulnerable, since distributions backport fixes, but the exposure is large.

The same nginx releases also fix five other bugs. The most serious, CVE-2026-118899, is an infinite loop when reading a request body over TLS 1.3 that lets an unauthenticated attacker stall a worker, in nginx 1.13.0 and later.

The Linux kernel bug is the sixth part of nginx2root. Xint found a use-after-free in the kernel’s SCTP send path, present since Linux 4.15 (2018): while a send operation waits, its SCTP association can be moved to another socket, and the waiting send can then free it. An attacker who already runs code as the nginx worker can use it to gain root on the host, and Xint did this from an nginx running inside a Docker container. Many distributions load the SCTP module automatically the first time a program opens an SCTP socket, so hosts that never use SCTP can still be exposed. As of November 18, no kernel fix was available and Xint was withholding the details until there is one.

As of November 19, none of the five nginx2root CVEs is in CISA’s Known Exploited Vulnerabilities catalog, and we have not seen reports of exploitation in the wild. Xint and Wiz Research have not released their exploits. Rapid7 has published a proof of concept, which it describes as suitable only for demonstrating the attack against a freshly started local container. Fake ‘exploits’ are also circulating on GitHub.

Why Cloudflare’s proxy protects your origin

nginx2root’s most dangerous bugs live in how nginx parses and manages HTTP/2 and HTTP/3 connections. To trigger them, an attacker has to send a carefully ordered stream of protocol frames directly to the nginx process: billions of WINDOW_UPDATE frames, a SETTINGS frame that holds response data back, PING frames that fill the send buffers, partial HEADERS frames, RST_STREAM at exactly the right moment.

When your DNS record is proxied through Cloudflare, that connection ends at our edge.

Cloudflare reads the client’s HTTP request, applies your security and caching rules, and then makes its own request to your origin over a connection Cloudflare controls. The flow-control frames, pings, settings, and stream resets that the attacker sends are consumed by our edge. They are not forwarded. Your nginx only ever sees the requests Cloudflare chooses to send, framed the way Cloudflare frames them. This also holds when Cloudflare connects to your origin over HTTP/2: Cloudflare runs its own flow control on that connection and sends WINDOW_UPDATE and RST_STREAM frames only as its own traffic needs, so a client can’t make it relay the billions of WINDOW_UPDATE frames the attack requires.

Rapid7 makes the same point in its analysis of CVE-2026-123007: if the HTTP/2 connection is proxied, the attacker’s frames “will likely not be retransmitted” in a way that allows exploitation. This breaks each of the HTTP/2 and HTTP/3 attacks.

CVE

What the attacker needs

Behind Cloudflare’s HTTP proxy

CVE-2026-123007

Direct control over HTTP/2 WINDOW_UPDATE, SETTINGS, PING and RST_STREAM on one connection to nginx

Protected. Control frames terminate at Cloudflare’s edge.

CVE-2026-123633

The first part of a HEADERS frame on a direct HTTP/2 connection, plus the ability to exhaust nginx connection slots and reset the TCP connection

Protected. The client’s HTTP/2 connection terminates at Cloudflare.

CVE-2026-121810

A direct QUIC/HTTP/3 connection to nginx

Protected. HTTP/3 terminates at Cloudflare’s edge. We do not communicate to origins over HTTP/3

CVE-2026-123634

A request and its mirror or SSI subrequest waiting on the same DNS lookup, and the main request ending while the answer is processed. In Xint’s exploit, nginx’s resolver had to reach the attacker’s DNS server.

Not fully protected. Depends on how your config builds proxy_pass. Patch.

CVE-2026-113425

A direct IMAP/POP3/SMTP connection to the nginx mail proxy

Not protected. Cloudflare’s HTTP proxy does not carry mail traffic.

There is one condition to be protected by Cloudflare here: your origin must not be reachable directly. If an attacker can find your origin’s IP and connect to it directly (TCP 443 or 80 for HTTP/2, UDP 443 for HTTP/3, or the mail ports), Cloudflare isn’t in the path and the protection doesn’t apply. You should ensure that your origin servers can only be accessed through Cloudflare’s proxies, using one of the following approaches:

  • Cloudflare Tunnel. Your origin makes an outbound-only connection to Cloudflare and exposes no inbound ports.
  • Firewall to Cloudflare IP ranges. Accept inbound HTTP/HTTPS only from Cloudflare’s published IP ranges. This must be done using an IP firewall, not based on configuration in your nginx server.
  • Authenticated Origin Pulls (mTLS). Your origin rejects any TLS connection that doesn’t present Cloudflare’s client certificate.

Xint’s own exposure check makes the same point: “If a CDN or reverse proxy sits in front of nginx, the test only reaches the proxy, so also run it directly against the nginx server.”

Where the protection does not apply

There are several situations in which Cloudflare’s HTTP proxy does not provide protection.

  • Spectrum TCP/UDP applications. For these configurations, traffic from the Internet is passed unmodified through to your origin. If your origin is running nginx, patch or disable the affected features.
  • nginx mail proxy. Cloudflare’s HTTP proxy does not carry IMAP, POP3 or SMTP. Restrict mail listeners to trusted networks until patched.
  • CVE-2026-123634 (resolver). This depends on how your configuration builds the proxy_pass target from the request, combined with a carefully timed cancellation of an HTTP request. Passing your traffic through Cloudflare’s proxy makes it harder to exploit this, but does not provide full protection. Update regardless.
  • DNS-only (grey-cloud), internal or non-proxied nginx. Any nginx server an attacker can reach without going through Cloudflare, including internal services behind a compromised host, needs to be patched.

Cloudflare’s WAF rules are not relevant to these vulnerabilities. These are protocol-level bugs. Because Cloudflare’s proxy handles parsing the HTTP protocol messages, and creates new messages to fetch information from origin servers, origins behind Cloudflare’s HTTP proxy are protected from the HTTP/2 and HTTP/3 bugs without needing a rule. We have therefore not released a managed rule. The protection comes from connection termination, not from pattern matching.

What to do now

  1. Find every nginx server. Include nginx Plus, distribution packages, container images and appliances. Run nginx -V and nginx -T on each and note HTTP/2, HTTP/3/QUIC listeners, proxy_pass with variables plus SSI or mirror, and any mail block.
  2. Patch. Update nginx Open Source to 1.30.7 or 1.31.9, nginx Plus to 37.0.8.1 or 37.3.0.1, or your distribution’s fixed package. F5 lists nginx Plus R34 to R36 as affected with no fixed build, so move those to a fixed 37.x release. Then restart nginx or complete a binary upgrade. A config reload does not replace the running binary.
  3. Check backport versions carefully. Distributions often patch without changing the version nginx -v reports. Compare the full package version against your distribution’s advisory.
  4. Make sure your origin is only reachable through Cloudflare. Use Tunnel, IP allowlisting or Authenticated Origin Pulls.
  5. If you can’t patch yet, disable what you don’t need. http2 off; (nginx 1.25.1 and later; on older versions, remove http2 from the listen directive) blocks CVE-2026-123007 and CVE-2026-123633. Removing QUIC listeners and setting http3 off; blocks CVE-2026-121810. Point proxy_pass at fixed upstream groups for CVE-2026-123634. Don’t rely on mirror_request_body alone: Xint’s tested setup set it to off, and the default on stopped that exploit, but SSI and other subrequests can still reach the bug. Bind mail listeners to trusted networks for CVE-2026-113425. Restart so old connections close.
  6. Block SCTP if you don’t use it. Add install sctp /bin/false to a file in /etc/modprobe.d/ to stop the kernel module from loading. This doesn’t unload an already-loaded module or disable SCTP built into the kernel. When your distribution ships a kernel update for the SCTP bug, install it and reboot. Blocking the module is a stopgap until then.

The Cloudflare Radar Zero Wire entry for nginx2root has the full checklist, a prompt you can give an agent to run a read-only assessment of your fleet, and links to every vendor advisory.

Technical deep dive

Let’s dig into the details of the five bugs by looking through the code. We’re looking at nginx 1.31.8 (commit 140aa94) which was the most recent code published before the fixes, and comparing this to the fixes in 1.31.9 (which were also included in release 1.30.7 on the stable branch).

A note on methodology: we based our analysis on the public advisories, and to verify our reading of the code, we built the public 1.31.8 and 1.31.9 releases with AddressSanitizer and ran tests for four of the five bugs (flow control, HTTP/2 use-after-free, resolver and mail proxy). Each one faults on 1.31.8 and runs clean on 1.31.9. We did not reproduce the HTTP/3 bug; that section is based on the fix commit and the published analysis.

One pattern, in four places

Four of the five bugs are use-after-free bugs. This is a common issue with programs that manually manage memory without language support: one part of the code frees an object that another part is still using.

nginx is event driven. A handler runs, calls other code, and that code returns to the handler. Three of the bugs occur when the called code tears down the connection or request the handler is working on. In the fourth, a second connection still holds a pointer to the object.

  • CVE-2026-123633 and CVE-2026-121810. A request needs a connection slot to reach its upstream. nginx is low on slots, so it closes an idle connection to free one. The connection it chooses is the one the request belongs to.
  • CVE-2026-123634. A resolver callback ends a request. Cleanup of that request frees a second resolver context that the resolver is about to call next.
  • CVE-2026-113425. When a write to a mail client fails, the client connection is closed while the connection to the authentication service still points at its session.

F5 rates all four as potential code execution if address space layout randomization (ASLR) is disabled or bypassed, and in its tests Xint reports code execution with the privileges of the nginx worker.

The fifth bug, CVE-2026-123007, is of a different kind: an accounting error that becomes a length error.

CVE-2026-123007: two flow-control pieces that each look correct

HTTP/2 flow control limits the amount of response data a server may send. nginx tracks a send window for each stream and one for the connection, h2c->send_window. The client enlarges a window with a WINDOW_UPDATE frame, and the protocol caps every window at 2^31 − 1.

nginx enforces that cap when a WINDOW_UPDATE arrives (ngx_http_v2_state_window_update()):

if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
   /* logs "client violated connection flow control" */
   return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
}

On its own, this check is correct. But the connection window also grows in a second place. When nginx queues DATA frames for a stream, it subtracts their length from the window. If the stream is canceled before those frames go out, ngx_http_v2_filter_cleanup() takes them off the queue and returns the credit:

h2c->send_window += window;

Nothing caps this line. As the fix commit describes, if the client enlarges the connection window after the frames are queued and before the stream is terminated, the refund pushes the window past 2^31 − 1.

From that point the first check no longer works. h2c->send_window is an unsigned size_t, so NGX_HTTP_V2_MAX_WINDOW - h2c->send_window wraps around to a very large number and every subsequent WINDOW_UPDATE is accepted. The client can then raise the window as far as it wants.

The window is unsigned, but the code that sizes DATA frames compares it as a signed value (ngx_http_v2_send_chain()):

if (limit == 0 || limit > (off_t) h2c->send_window) {
   limit = h2c->send_window;
}
...
if ((off_t) frame_size > limit) {
   frame_size = (size_t) limit;
}

After the window passes 2^63, it is negative as an off_t. The frame size becomes the window value itself, a number between 2^63 and 2^64, and nginx builds a buffer whose last pointer lies before its pos pointer.

Over TLS, that buffer reaches a memcpy() in ngx_ssl_send_chain() with that length. Our TLS test stops at that point under AddressSanitizer. Xint’s write-up explains how, with the window pushed close to 2^64, this turns into a controlled out-of-bounds write and an address leak, and Xint, Rapid7, and Wiz each report code execution from it. This post goes no further than the fault.

Over cleartext HTTP/2, the same invalid buffer follows a different output path. Our cleartext test also faults under AddressSanitizer on 1.31.8 and runs clean on 1.31.9. The public write-ups address the TLS case.

How much traffic the known attacks require

The biggest step a WINDOW_UPDATE can take is 2^31 − 1, and a WINDOW_UPDATE frame is 13 bytes. Bringing a 64-bit window near its top therefore requires about 2^33 frames: roughly 8.6 billion frames, or about 112 GB (104 GiB).

Rapid7, which published a proof of concept, gives the same figure and adds that nginx limits control-frame traffic relative to other traffic on the connection, so its run also sends about 15 GiB of other request traffic. Its total comes to approximately 128 GB of HTTP/2 data: about two minutes on a 10 Gbit/s link and about seventeen minutes at 1 Gbit/s. Rapid7 estimates the WINDOW_UPDATE traffic needed to reach 2^63 at about 2^32 frames, or 52 GiB, half of the 104 GiB figure. It also notes that these figures describe its route and are not a proven minimum.

For defenders, this is the useful fact about the bug. At this volume, the known attacks are hard to hide: nginx receives tens of gigabytes from a single client over one long-lived connection and sends little back, much more than the requests in the access log account for.

Why it was difficult to find

The refund line has existed in nginx since HTTP/2 support arrived in 1.9.5 in 2015. Two things made it difficult to notice.

First, each piece looks correct on its own. The check on WINDOW_UPDATE is the right check. The refund is the right refund. The bug is that the check relies on an assumption the refund does not preserve.

Second, testing that waits for a crash is very unlikely to reach it, because a crash requires tens of gigabytes of input. The bad state itself can be reached with very little traffic: Censys published a cleartext test that reaches what it calls the corrupted flow-control state with a 5.69 MB capture. A test that asserts “the send window never exceeds its protocol maximum” after every frame would flag the bad state as soon as a test sequence got there. A test that waits for memory corruption would not.

The fix

The fix (6 lines added) introduces a counter, h2c->send_queued, for DATA that is queued but not yet sent. The WINDOW_UPDATE check now includes those bytes in the window:

if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {

From the client’s perspective, queued frames still count toward the window, so the client can no longer refill credit that nginx is about to refund. On a fixed version the attempt is rejected with a flow-control error.

CVE-2026-123633: where two protections interact

An nginx worker has a fixed number of connection slots (worker_connections), which the client and upstream connections share. Since 1.19.2, when free slots run low (1/16 of the total or fewer), ngx_get_connection() calls ngx_drain_connections(), which closes connections marked “reusable”: connections with nothing in progress, such as idle keep-alive connections.

This works only if a reusable connection truly has nothing in progress. For HTTP/2 that was not always the case. Two commits landed on the same day in February 2021 and were released together in 1.19.7:

  • “HTTP/2: fixed reusing connections with active requests” fixed a case in which a cleartext HTTP/2 connection could remain reusable while it had a request.
  • “HTTP/2: reuse of connections with incomplete frames” registered a connection as reusable while it waits for the remainder of a partly received frame, so that a client cannot hold slots with partial frames.

The second change is the relevant one here. As the fix commit explains, if the remainder of that frame is a HEADERS frame, a stream is created, but the reusable status was not reset until the connection next went idle. The connection then has a request and remains in the reusable queue.

If that request is proxied, nginx requests a slot for the upstream connection. If slots are short, the drain runs inside that call and can choose this same connection. The drain instructs the connection to close and nginx attempts to send GOAWAY. If that send fails, nginx frees the connection and every stream on it. Control then goes back to the upstream code, which continues to use the request it was called for.

Each change made sense on its own. The interaction between them was subtle and stayed unnoticed until this year. F5’s advisory credits Albert Ebb of Metnir, Nir Ohfeld at Wiz Research, Xint.io and memN0ps of Palo Alto Networks Unit 42; nginx.org’s changelog credits Albert of Vexera AI.

The fix

Two lines added: ngx_http_v2_create_stream() now calls ngx_reusable_connection(h2c->connection, 0). A connection that has a stream is never reusable, regardless of the state it was in before.

CVE-2026-121810: the same idea, in QUIC

According to the fix commit and Xint’s analysis, the HTTP/3 bug reaches the same result by a different route.

In nginx’s QUIC code, each QUIC connection uses one connection slot and each stream uses another. A QUIC connection may be drained only when every stream remaining in its tree can be cancelled, and nginx determines this by walking the connection’s tree of streams.

ngx_quic_create_stream() removes the QUIC connection from the reusable queue and then requests a slot for the new stream. Before the fix, the new stream was added to the tree only after that. If the slot request triggered a drain that closed another, idle stream of the same QUIC connection, the code handling the closed stream walked the tree, did not find the stream being created, concluded the connection was idle, and made it reusable again. A later drain, for example when the new request connects to its upstream, could then close the QUIC connection while that request was running.

F5’s advisory states that exploitation “also depends on conditions beyond the attacker’s control”. Xint writes that the bug “is triggered by a slightly different mechanism” from the HTTP/2 one.

The fix

Four lines added: the stream goes into the tree before the slot is requested, and is taken out again on the error paths.

CVE-2026-123634: freeing the next item of a list during the walk

When proxy_pass contains a variable, nginx resolves the host name while handling the request. If a lookup for the same name is already in progress, the new request waits on the same resolver node. When the answer arrives, nginx detaches the list of waiting contexts and calls each in turn:

next = rn->waiting;
rn->waiting = NULL;

while (next) {
   ctx = next;
   ...
   next = ctx->next;

   ctx->handler(ctx);
}

The loop stores next before the handler call, so a handler may free its own context. The trouble starts when a handler frees a different context in the same list. This happens when two contexts belong to one request, as with a request and its mirror subrequest resolving the same name (the case Xint tested; F5 also lists SSI subrequests). If the first handler ends the request, the request’s cleanup calls ngx_resolve_name_done() for the second context. That function searches the node’s waiting list for the context, does not find it because the list has been detached, and frees the context regardless. The loop then advances to the freed context.

Usually nginx logs this. On vulnerable versions, when the search fails, it writes

could not cancel <name> resolving

to the error log at alert level. This line is worth searching for. It is not proof either way: the fix commit notes that one variant, while following a CNAME, produced no alert.

The fix

A context cancelled while it sits in a detached list is no longer freed immediately. Its handler is swapped for one that frees it when the loop gets to it (31 lines added). The fix also downgrades the alert to a debug message, so the line above shows up at alert level only on unpatched versions.

CVE-2026-113425: two connections, one session

With auth_http, the mail proxy asks an HTTP service to verify each login. During the wait, it holds two connections for one session: the client connection and the connection to the authentication service. The second points at the session and uses the memory pool of the client connection.

Before the fix, the reply the protocol handler had prepared for the client remained queued while the authentication request was in progress, and the client’s write handler was still ngx_mail_send(). If that handler ran and the write failed because the client had reset the connection, it closed the client connection and destroyed the session. The authentication connection still pointed at the session, and the next event on that connection used freed memory.

Xint describes two conditions for this: the client’s write event must already be registered (for example, because the client stopped reading replies), and the login command and the reset must be handled in the same pass of the event loop. Valid credentials are not needed, because this happens before the login is checked.

The fix

Two added lines discard the queued reply when the authentication request begins. The same release contains three further commits that block client writes while the proxy waits for the authentication response, while it connects to the upstream and reads its greeting, and while it resolves an SMTP client’s address and name.

What the fixes share

The five fixes each involve minor corrections to the code. They add between 2 and 31 lines each, and the mail proxy fix came with three further commits. There is no design change needed. Each fix restores an invariant that the rest of the code already depended on:

  • a send window never goes above the protocol maximum
  • a connection with a request in progress is never reusable
  • an object that other code is about to use is not freed out from under it

In every case, one code path failed to keep a rule that the rest of the code relied on, and the fix makes that path keep it. As code is modified over time, it is very easy for these kinds of rules to become broken.

What to watch for

Attempts to exploit this will typically trigger some characteristic log messages. Three of these messages (the two at info and the one at warn) fall below nginx’s default error_log level of error and appear only if a lower level is set. The alert messages are logged by default.

Bug

Log messages or other signals

CVE-2026-123007

A single long-lived HTTP/2 connection on which nginx receives tens of gigabytes from a client and sends little back, much more than its logged requests account for. On fixed versions a rejected attempt logs client violated connection flow control: received WINDOW_UPDATE frame with window increment ... not allowed for window ... (level info; older versions have the same message for ordinary violations). http2 flood detected (level info) on such a connection can be a failed attempt, but nginx also logs that message for several other limits.

CVE-2026-123633, CVE-2026-121810

worker process <pid> exited on signal 11 (level alert) on servers that accept HTTP/2 or HTTP/3 and proxy to an upstream, along with worker_connections are not enough, reusing connections (level warn). A use-after-free does not always crash.

CVE-2026-123634

could not cancel <name> resolving (level alert, unpatched versions only). The absence of this message does not rule the bug out.

CVE-2026-113425

Worker crashes in a mail proxy using auth_http, with client connections reset during login.

All five

Unexpected programs launched by an nginx worker process, for example from an auditd rule on execve for the worker’s user. Xint recommends this check, and it is the strongest sign of a successful attack.

Timeline

Date (UTC)

Event

Oct 11, 2026

Xint discovers the vulnerabilities

Oct 16, 2026

Reported to F5 via HackerOne

Oct 27, 2026

Reports delivered to the nginx development team

Nov 10, 2026

Xint completes patch validation

Nov 18, 2026

Public disclosure; nginx 1.30.7 and 1.31.9 released

Closing

CVE-2026-123007 sat in nginx for more than ten years. The SCTP bug has been in the Linux kernel since 2018. Xint says one of its researchers found CVE-2026-123007 by hand and an automated Xint scan found the other four nginx bugs. Several other teams found the two HTTP/2 bugs independently. Meanwhile, nginx’s advisory list has gone from two entries in 2025 to 36 so far this year. AI-assisted research is finding bugs in heavily reviewed code faster than before, and more disclosures like this one are coming.

That’s a large part of why it’s worth putting Cloudflare in front of your origin. A protocol bug in your web server becomes much less of a risk when the attacker can’t speak that protocol to your server directly. Our edge is not affected, and the HTTP/2 and HTTP/3 attacks against your nginx end at our network. Patch anyway, lock down your origin so Cloudflare is the only way in, and use the Radar Zero Wire page to check your fleet.

Sources

Read more here: https://blog.cloudflare.com/nginx2root/

The post nginx2root: Five new nginx vulnerabilities, and how Cloudflare protects origins from the worst of them appeared first on IPv6.net.

]]>
Waveshare ESP32-S31-Touch-LCD-4.3C – An ESP32-S31 4.3-inch display devkit with optional DIN rail case https://ipv6.net/news/waveshare-esp32-s31-touch-lcd-4-3c-an-esp32-s31-4-3-inch-display-devkit-with-optional-din-rail-case/ Thu, 19 Nov 2026 14:37:05 +0000 https://ipv6.net/?p=2927233 Last month we wrote about VIEWE’s ESP32-S31 4.3-inch touch display, but there’s now another option, namely the Waveshare ESP32-S31-Touch-LCD-4.3C development kit. Both models are similar, with an ESP32-S31 module equipped with 16MB flash and 16MB PSRAM, a 4.3-inch 800×480  touchscreen display, RS485 and CAN Bus interfaces, and more. The EVIEW model supports 16.7M colors, while […]

The post Waveshare ESP32-S31-Touch-LCD-4.3C – An ESP32-S31 4.3-inch display devkit with optional DIN rail case appeared first on IPv6.net.

]]>
Waveshare ESP32-S31-TOUCH-LCD-4.3C

Last month we wrote about VIEWE’s ESP32-S31 4.3-inch touch display, but there’s now another option, namely the Waveshare ESP32-S31-Touch-LCD-4.3C development kit. Both models are similar, with an ESP32-S31 module equipped with 16MB flash and 16MB PSRAM, a 4.3-inch 800×480  touchscreen display, RS485 and CAN Bus interfaces, and more. The EVIEW model supports 16.7M colors, while the Waveshare devkit is limited to 65K colors, but it offers a wider 7V-36V voltage input, an optional DIN rail enclosure, and 3.7V Lithium battery support. Waveshare ESP32-S31-Touch-LCD-4.3C specifications: Wireless module – ESP32-S31-WROOM-3-N16R16V SoC – ESP32-S31NRV16 CPU RISC-V HP (High-performance) RV32IMAFCP CPU @ 320 MHz with FPU, SIMD, etc. RISC-V LP (Low-power) MCU core Memory – 512 KB SRAM, 32 KB low-power SRAM, 16MB PSRAM Wireless – 2.4 GHz WiFi 6 (802.11ax) Bluetooth 5.4 with support for LE Audio, direction finding, Bluetooth Mesh 1.1, and Classic (BR/EDR) 802.15.4 radio for Zigbee, Thread, and Matter Storage […]

The post Waveshare ESP32-S31-Touch-LCD-4.3C – An ESP32-S31 4.3-inch display devkit with optional DIN rail case appeared first on CNX Software – Embedded Systems News.

Read more here: https://www.cnx-software.com/2026/11/19/waveshare-esp32-s31-touch-lcd-4-3c-an-esp32-s31-4-3-inch-display-devkit-with-optional-din-rail-case/

The post Waveshare ESP32-S31-Touch-LCD-4.3C – An ESP32-S31 4.3-inch display devkit with optional DIN rail case appeared first on IPv6.net.

]]>
Arduino Holiday Gift Guide: Get their next project wrapped up early https://ipv6.net/news/arduino-holiday-gift-guide-get-their-next-project-wrapped-up-early/ Thu, 19 Nov 2026 14:07:06 +0000 https://ipv6.net/?p=2927222 Some people are easy to shop for. Others, not so much. Then there’s the person who takes things apart to see how they work, has strong opinions about game controllers, or hears a synthesizer and wonders how to build one. You know what they love. But choosing hardware for them? That’s where things can get […]

The post Arduino Holiday Gift Guide: Get their next project wrapped up early appeared first on IPv6.net.

]]>

Some people are easy to shop for. Others, not so much. Then there’s the person who takes things apart to see how they work, has strong opinions about game controllers, or hears a synthesizer and wonders how to build one. You know what they love. But choosing hardware for them? That’s where things can get complicated.

Our Arduino Holiday Gift Guide helps you connect their interests to something they can make. Whether you’re shopping for an electronics beginner or an experienced maker with an ambitious project in mind, here’s where to start.

For the endlessly curious — Arduino gifts for electronics beginners

Know someone who’s always asking how stuff works? Give them a way to find out. The Arduino® Plug and Make Kit™ is a welcoming first step. Its modular components connect without a tangle or loose jump wires, helping beginners to get hands-on electronics and start experimenting.

For the person on your gift list who likes to understand each connection, choose the Arduino® Starter Kit™. An Arduino® UNO™ R3 board, more than 100 components, and a printed book with 15 guided projects give them a structured introduction to building and programming circuits.

And if robots are what sparks their curiosity, Arduino® Alvik™ robot kit gives them a programmable companion for exploring how to translate into movement.

Arduino opens up a world of possibilities for the music lover and indie game creator

Music lovers are easy to spot. They’re the ones tapping out rhythms on their desks, humming melodies no one else recognizes, or turning up the volume when their favorite song comes on. And some aren’t content with listening. They want to create music themselves.

Then there are the gamers who dream of designing their arcade machines, inventing new ways to play, or build a controller nobody’s ever seen before. For both, Arduino opens up a playground of possibilities. From custom synthesizers and electronic instruments to arcade-style controllers and interactive games, makers can combine coding, electronics, and imagination to create something entirely their own.

Know someone who would rather build the experience than simply enjoy it? An Arduino board or kit might just be the right gift to get them started.

For complex builds: UNO Q gifts for engineering and hardware hackers

Give the engineer or hardware hacker in your life  a perfectly good reason to spend the weekend at their workbench by choosing the UNO Q configuration that fits what they want to tackle next.

For developers who demand serious computing power and real-time responsiveness, the UNO Q offers something intriguing: a Linux computer and a microcontroller working together on a single board. One handles sophisticated computing tasks while the other delivers precise hardware control. It’s a powerful combination for bringing software intelligence into the physical world.

Think computer vision, machine learning and edge AI applications that process data locally, right on the device, without depending on the cloud. With Arduino App Lab, developers can bring these capabilities together with hardware control to prototype intelligent, responsive systems.

For engineers who’re always pushing the limits of what’s possible, UNO Q offers plenty of room to experiment. And chances are, they’ve already got several projects in mind.

For teacher and STEM club mentors

There’s nothing like watching a student’s face light up when their first circuit works or their code brings a project to life. For teachers and STEM club mentors and advisors, those moments make all the planning worthwhile.

Arduino makes hands-on learning easier with classroom-ready packs designed for group activities, multiple student licenses, and free curriculum materials that help educators turn complex concepts into engaging lessons. Replacement components sets also help keep the learning going when parts get lost or worn out.

Whether you’re introducing students to electronics or guiding their next big STEM challenge, Arduino gives you the tools to inspire the next generation of innovators. Select the perfect gift for your students at great holiday prices.

Which Arduino gift fits your budget?

You don’t need a huge budget to get someone building. The gift guide’s under $100 selection includes the Plug and Play Make Kit, Starter Kit, and UNO Q Arcade and DIY Synth  bundles at promotional prices.

Have more room to spend? The over $100 selection includes Alvik and classroom kits for learning together. Choose by interest and experience first, then use the price categories  to narrow your options. A well-matched first project can be far more appealing than hardware  they aren’t ready to use.

Found their next project? Make it their holiday gift

You have the perfect person in mind. Now give them a gift they’ll be itching to open and put to work. Shop the Arduino Holiday Gift Guide and save up to 50% on selected products.

Arduino, Plug and Make, Starter Kit, UNO, Alvik, and Giga are trademarks or registered trademarks of Arduino S.r.l.

The post Arduino Holiday Gift Guide: Get their next project wrapped up early appeared first on Arduino Blog.

Read more here: https://blog.arduino.cc/2026/11/19/arduino-holiday-gift-guide-get-their-next-project-wrapped-up-early/

The post Arduino Holiday Gift Guide: Get their next project wrapped up early appeared first on IPv6.net.

]]>
SwitchBot Hub 4 Smart Home controller supports Matter 1.3, Hello Kata voice control, over 101,000 infrared devices https://ipv6.net/news/switchbot-hub-4-smart-home-controller-supports-matter-1-3-hello-kata-voice-control-over-101000-infrared-devices/ Thu, 19 Nov 2026 04:37:05 +0000 https://ipv6.net/?p=2927178 SwitchBot Hub 4 is a Smart Home control hub with a color display, physical controls (buttons and know), Hello Kata voice control, WiFi and Bluetooth connectivity, and Matter Bridge 1.3 support. It supports over 101,000 infrared appliances, including air conditioners, televisions, projectors, fans, streaming devices (Fire TV, Apple TV, and Android TV), and more. For […]

The post SwitchBot Hub 4 Smart Home controller supports Matter 1.3, Hello Kata voice control, over 101,000 infrared devices appeared first on IPv6.net.

]]>
SwitchBox Hub 4

SwitchBot Hub 4 is a Smart Home control hub with a color display, physical controls (buttons and know), Hello Kata voice control, WiFi and Bluetooth connectivity, and Matter Bridge 1.3 support. It supports over 101,000 infrared appliances, including air conditioners, televisions, projectors, fans, streaming devices (Fire TV, Apple TV, and Android TV), and more. For devices that are not part of the list, you can also use the IR learning function. The hub can also control Bluetooth HID devices, SwitchBot devices, and Matter devices via on-screen touch shortcuts and the rotary knob.   SwitchBot Hub 4 (W108021000) specifications: SoC – Not specified. Potentially ESP32-S3. Display 2.8-inch IPS color LCD with 240 x 320 resolution Bottom touch area Shows time, weather, temperature/humidity, device status, and scene/shortcut entries Audio 2W full-range speaker 2x omnidirectional microphones Voice wake-up with “Hello Kata” within a 3 m range Voice control for devices, alarm creation, and […]

The post SwitchBot Hub 4 Smart Home controller supports Matter 1.3, Hello Kata voice control, over 101,000 infrared devices appeared first on CNX Software – Embedded Systems News.

Read more here: https://www.cnx-software.com/2026/11/19/switchbot-hub-4-smart-home-controller-supports-matter-1-3-hello-kata-voice-control-over-101000-infrared-devices/

The post SwitchBot Hub 4 Smart Home controller supports Matter 1.3, Hello Kata voice control, over 101,000 infrared devices appeared first on IPv6.net.

]]>
Scaling massive AI/ML workloads with IPv6 on Google Kubernetes Engine clusters https://ipv6.net/news/scaling-massive-ai-ml-workloads-with-ipv6-on-google-kubernetes-engine-clusters/ Wed, 18 Nov 2026 17:37:04 +0000 https://ipv6.net/?p=2927138 TL;DR: Single-stack IPv6 on GKE runs both nodes and pods without having to use private IPv4 addresses. Available in preview for Cloud TPU v6e and CPU node pools, including Axion, it works with DNS64/NAT64 to reach IPv4 endpoints. Long before they run out of compute or power, AI applications hit another wall: running out of […]

The post Scaling massive AI/ML workloads with IPv6 on Google Kubernetes Engine clusters appeared first on IPv6.net.

]]>

TL;DR: Single-stack IPv6 on GKE runs both nodes and pods without having to use private IPv4 addresses. Available in preview for Cloud TPU v6e and CPU node pools, including Axion, it works with DNS64/NAT64 to reach IPv4 endpoints.

Long before they run out of compute or power, AI applications hit another wall: running out of IP addresses. A single AI deployment often requires a vast address space to support everything from thousands of accelerator nodes, scaling inference replicas, bursting Ray workers and pipelines, pod sidecars, and services like vector databases. Running a dual stack — IPv6 behind a private IPv4 space — can help, but only to a point, because the private IPv4 space has often already been exhausted across existing networks. 

To help, today, we’re announcing single-stack IPv6 on Google Kubernetes Engine (GKE), allowing you to run both nodes and pods on IPv6, without private IPv4 addresses. Single-stack IPv6 is available in preview for Cloud TPU v6e and CPU node pools, including Axion, and works with DNS64/NAT64 to reach IPv4 endpoints.

image1

Nodes and pods run IPv6-only across Cloud TPU v6e and CPU-based node pools, with no private IPv4. Workloads reach Google Cloud APIs over native IPv6 and IPv4-only endpoints through DNS64/NAT64.

What single-stack IPv6 delivers

The availability of single-stack IPv6 in GKE is a game-changer for large AI deployments. Consider the following features and benefits that it brings to the table:

1. No private IPv4 required for nodes or pods
Nodes and pods use IPv6 exclusively. Without the RFC 1918 footprint that governs private IPv4 address spaces, clusters avoid conflicts with on-premises networks, peered VPCs, or adjacent clusters.

2. IPv4 interoperability with DNS64/NAT64
You enable DNS64 on the VPC, and NAT64 on a regional Cloud NAT gateway, allowing pods to transparently reach IPv4-only endpoints, registries, and dataset hubs — refer to the documentation to learn how to configure DNS64 and set up Cloud NAT.

3. Massive address space per node
Each node receives a /112 pod range (65,536 addresses), so IP address capacity no longer limits how high your clusters, nodes, or pods can scale. Standard GKE maximum-pods-per-node limits still apply.

4. Broad accelerator and compute support
We designed single-stack IPv6 in GKE with the goal of supporting a range of accelerators and general compute families. At preview, it supports Cloud TPU v6e (Trillium), plus E2, N1, N2, N2D, N4, C3, C3D, C4, C4D, C4A, and Z3 machine families, with support for additional accelerators and machine families coming soon.

5. Direct workload observability
Every pod has a unique IPv6 address without having to run NAT inside the cluster, simplifying telemetry, network policies, and debugging.

Performance and scale

Single-stack IPv6 removes private IPv4 address limits without additional data plane overhead. In our internal testing, we saw the following performance characteristics:

  • Pod lifecycle: Burst pod scheduling and CNI sandbox setup performed at parity with IPv4.

  • Networking: Inter-node TCP/UDP latency and multi-stream pod-to-pod throughput matched IPv4. 

  • Services and DNS: eBPF service load balancing and NodeLocalDNS showed no measurable overhead compared to standard IPv4.

Start building today

Single-stack IPv6 is available now in preview on GKE version 1.37.1-gke.3020000

To create your first IPv6-only cluster, run the following commands, replacing REGION and CLUSTER_NAME:

code_block
<ListValue: [StructValue([(‘code’, ‘# 1. Create a VPC with internal (ULA) IPv6 enabledrngcloud compute networks create gke-ipv6-net \rn –subnet-mode=custom \rn –enable-ula-internal-ipv6rnrn# 2. Enable DNS64 for the VPCrngcloud dns policies create gke-ipv6-dns64 \rn –networks=gke-ipv6-net \rn –enable-dns64-all-queriesrnrn# 3. Enable NAT64 in your regionrngcloud compute routers create gke-ipv6-router \rn –network=gke-ipv6-net –region=REGIONrngcloud compute routers nats create gke-ipv6-nat64 \rn –router=gke-ipv6-router –region=REGION \rn –auto-allocate-nat-external-ips \rn –nat64-all-v6-subnet-ip-rangesrnrn# 4. Create the clusterrngcloud beta container clusters create CLUSTER_NAME \rn –cluster-version=1.37.1-gke.3020000 \rn –location=REGION \rn –enable-dataplane-v2 \rn –cluster-dns=clouddns \rn –stack-type=ipv6 \rn –network=gke-ipv6-net \rn –create-subnetwork name=my-subnet \rn –ipv6-access-type=internal’), (‘language’, ”), (‘caption’, <wagtail.rich_text.RichText object at 0x7faa40e8b2d0>)])]>

To learn more, see the documentation.

Read more here: https://cloud.google.com/blog/products/networking/run-aiml-workloads-on-ipv6-only-gke-clusters

The post Scaling massive AI/ML workloads with IPv6 on Google Kubernetes Engine clusters appeared first on IPv6.net.

]]>