Here's the NIST link: <a href="https://nvd.nist.gov/vuln/detail/cve-2026-98432" rel="nofollow">https://nvd.nist.gov/vuln/detail/cve-2026-98432</a><p>Here are my notes so far after digging into this with Claude + defensive access:<p>1. Not just an MPTCP thing - any received IPv4 packet with options creates the problematic conditions.<p>2. Also appears that using NetLabel/CIPSO (SELinux or Smack with a CIPSOV4 mapping) creates the same conditions that a packet with IP options would. If you're using these, it might mean that dropping IPv4 packets with IP options might not fully mitigate.<p>3. At least for our test VMs in Azure (accelerated networking) I wasn't able to get any IPv4 packets with options through, from three different US-based ISPs. Unfortunately Microsoft publishes no docs on whether the fabric drops this or not, so YMMV.<p>We're using a simple XDP program to mitigate until a patched kernel is available (thanks @tptacek for the idea):<p><a href="https://github.com/jamilbk/drop-ipv4-opt" rel="nofollow">https://github.com/jamilbk/drop-ipv4-opt</a>
> TCP Use-After-Free: CVE-2026-98432 / CVSS 9.8<p>I know it's customary for HN to edit titles to remove extraneous information, but removing "Linux" here really takes away something useful and relevant. This is a Linux vulnerability. If you're running *BSD or Mac or Windows, not affected.
Quite, however it looks quite rare:<p>"Why it's urgent: the bug sits in code every Linux server runs when it accepts an IPv4 TCP connection, before any application sees the connection. Anthropic, whose researcher reported it, says its Claude model wrote a working proof-of-concept exploit that runs commands as root on "Linux servers with a multipath TCP listener," with no credentials. Go programs open those listeners by default, per the Go Security Team. See the timeline."<p>I don't know of any Linux boxes running a multipath TCP listener in my care and I have quite a few. MP generally implies a router of some sort and the intersections in a Venn diagram continue to get smaller ...<p>This is still an issue and must be patched but I think it will be rare, very rare.
This is not rare. Every TCP connection in Go by default enables MPTCP [1]. Simply running a Go program that uses TCP without explicitly disabling this behavior will cause the running kernel to be vulnerable.<p>1: <a href="https://groups.google.com/g/golang-announce/c/PCoQcdxoScw" rel="nofollow">https://groups.google.com/g/golang-announce/c/PCoQcdxoScw</a>
the default on all of my RHEL is to have it disabled, I believe it's the same on Debian based<p>sysctl -a | grep net.mptcp.enabled
net.mptcp.enabled = 0<p>and golang apps would just gracefully downgrade to non mptcp in that case.
Does this mean Caddy is vulnerable? IIRC, I think it's written in Go.
*Since Go 1.24
But any sane configuration would have the MPTCP port blocked behind a firewall (unless you were intentionally using MPTCP).
Try:<p><pre><code> sudo ss -lnp -A mptcp
</code></pre>
to check. If you're running any Go code, you may be surprised. I was.
Allright, I removed stray anubis install I had on my vps, after running this.
Tailscale shows up.
i see lot of tailscale is running and isn't tailscale mostly written in Go?
Btw, one can switch it off for Go programs not only with env variable, but also in go.mod:<p><pre><code> godebug multipathtcp=0
</code></pre>
That's cool
It seems like the anthropic PoC involves MPTCP, but the bug itself is not in the MPTCP code, it's in a generic TCP codepath relating to options, MPTCP was probably just a convenient codepath for memory manipulation.
containerd (docker) uses it
"TCP stack" versus "Linux TCP stack" is an OOM in terms of relevance.
Some notes I've got about this:<p>- MPTCP is not a requirement, it is a generic use-after-free.<p>- Exploitability over the internet is unlikely, most ISP routers drop packets with IP options fields.<p>- At least according to Red Hat, dropping packets with IP options yourself helps, but is not a full mitigation.<p>- Successful exploit requires multiple CPU cores to process packets, so systems with just a single core or packet processing pinned to a single core are not affected.
> Exploitability over the internet is unlikely, most ISP routers drop packets with ipoptions fields.<p>That doesn't track. Apple iPhones are a major user of MPTCP and they report the majority of requests supporting MPTCP, IIRC 70+%.
MPTCP uses TCP options fields, the vulnerability is in IP options.
There are two types of multipath TCP and they are not at all the same.<p>What Apple does is, for example, being able to have a connection over WiFi and 5G simultaneously, with different IPs and routes.<p>The more traditional server side multipath is that you have a network card with 4 ports (eg 4x 25gbit) and connect them to a router, and make those 4 physical ports (paths) behave like a single interface. This helps either load balancing or redundancy.<p>The latter is what this vulnerability is about.
That’s typically done with thinks like lacp, not multipath
Sorry but that's plain wrong.<p>Neither has layer 2 LAG nor has layer 3 ECMP anything to-do with layer 4 MPTCP.<p>What's vulnerable is MPTCP.
Dropping packets with IP options from XDP should be a more complete mitigation (also more performant).
Whipped something up: <a href="https://github.com/jamilbk/drop-ipv4-opt" rel="nofollow">https://github.com/jamilbk/drop-ipv4-opt</a>
<a href="https://en.wikipedia.org/wiki/Express_Data_Path" rel="nofollow">https://en.wikipedia.org/wiki/Express_Data_Path</a> for anyone else wondering what that is
Tragically not enough people drop IP options. I did it in the early 2000s for a very large US network and was glad. There's lots of obvious reasons as they're generally an old school ddos path to knock out routers (get punted to the RE/RP exception path, a good way to bypass some loopback/routing engine acls if folks don't filter it right). Every few years some academics pop up with let's use IP options because we can stuff more bullshit in the datagram - it's always a bad idea.
I'm wondering if Android is vulnerable, since it is based on Linux?
For more on why MPTCP is not relevant--my limited understanding is the issue is with SYN retransmits.<p>SYN packet #1 is received and added to a request queue for processing.<p>SYN packet #2 is received and is a retransmit of SYN packet #1. It is matched to SYN packet #1 already in the request queue and now there is shared state between both SYN packets #1 and #2 in the request queue.<p>CPU #1 takes on the task of processing SYN packet #1.<p>CPU #2 takes on the task of processing SYN packet #2.<p>CPU #1 responds back with RST packet #1 (e.g. requested TCP port is not open) and _should_ defer the destruction of the request socket for SYN packet #1, as other CPUs may still be processing the shared state for the request socket as is the case for retransmitted SYN packets.[1] However, this deferred destruction wasn't occurring, and CPU #1 was _immediately_ destroying the request socket/shared state for SYN packet #1.<p>CPU #2 races with CPU #1 and reads from the request socket/shared state for SYN packet #1 after its _immediate_ destruction by CPU #1.<p>Linux's IPv6 handling is unaffected because in this IPv6 scenario, there is no shared state between SYN packets #1 and #2 in the request queue. Instead, each request socket has duplicate data.<p>Someone more knowledgeable can confirm/correct me on the above please.<p>[1] <a href="https://www.kernel.org/doc/html/latest/RCU/whatisRCU.html#rcu-overview" rel="nofollow">https://www.kernel.org/doc/html/latest/RCU/whatisRCU.html#rc...</a>
Do<p>sudo tcpdump --immediate-mode -p -nn -i eth0 -vvv -c 1 'ip and (ip[0] & 0x0f > 5)'<p>to see if you even get them from upstream.<p>You can even ping it from outside with these packets in the meantime<p>ping -R -c 3 $IP
And it takes around an hour to do this in lab setting locally:<p>> An enabling property of this race condition is that a lost race only fails the handshake without crashing the whole system, so a determined attacker can retry indefinitely until they succeed. In our proof of concept, it takes 48 minutes to leak a kernel pointer and another five minutes to reach the shell command execution<p>source: <a href="https://www.anthropic.com/research/discovering-vulnerabilities-with-claude" rel="nofollow">https://www.anthropic.com/research/discovering-vulnerabiliti...</a>
How are Ubuntu and RHEL not fixed? Few operating systems market themselves more as suitable for servers. What are they doing over there?
If you read commit logs of, say kernel.org and a distro kernel, and aren't concerned you are blissfully ignorant (and it is worse for the broader userland repos). It's particularly bad when they don't track a kernel.org LTS. Their kernel orgs are pretty lean and this has been the status quo for decades. CVEs of sufficient stature like this will get fixed but majority of other issues slip by unnoticed. LTS is kind of a myth, it trades ABI and API stability for a lot of other issues.
"Their kernel orgs are pretty lean"<p>For years, Red Hat employed more kernel developers than anyone and contributed more. These days they're "only" the fourth largest contributor, after Intel, Google, and Meta, but they are still among the largest corporate contributors.<p>If that's a lean kernel org, I don't know what a fat one would look like.
Unfortunately, as a ZFS on Linux user, LTS is the best way to get continual updates without breaking my system.
I have found that Debian BPO kernel + BPO ZFS works well, and since ZFS gives you complete snapshotting capability a broken upgrade isn't as much of an issue, rolling back with zfsbootmenu is easy.
zfsbootmenu looks very cool, thanks for sharing!<p>What usually happens to me is that I run a full package update, forget about it for a while, and then reboot. And then the server doesn't come back online - and I'm not in front of it to fix it.<p>LTS kernel pretty much solved this issue for me when I switched.
Probably best to not leave any ZFS system connected to the internet then.
Over the past few months I've started to install newer ubuntu kernels using the mainline PPA. However, it goes long periods of time without getting updates, so it's not really a satisfactory solution. In one case I just built the kernel myself.<p>LTS doesn't work if you want immediate fixes like the current environment requires.
Given the current and rapidly upcoming environment, would that not imply that those are no longer viable choices? As like a fairly urgent emergency consideration?<p>If they cannot demonstate being systematically able to adapt towards the required reaction time (minutes? hours?) by almost-comically many orders of magnitude (multiple weeks), and it is only going to get worse, then what other conclusion could there be?<p>Like they'll only organizationally adapt when it's far too late (everybody using their shit has already been pwned), and then it'll be an unpracticed emergency adaptation.
No, they are providing a service, LTS, that customers still want and pay for. Only once the customers realise its not a workable product and they want a rolling update product, with all the changes that implies, will this change.
> <i>How are Ubuntu and RHEL not fixed?</i><p>Ubuntu has had kernels in the "proposed" component for several days now if you want to pull it in manually. Not yet pushed to "security" or "updates".
I’m pretty confused because apparently Anthropic is the group that followed “responsible disclosure” but apparently even though upstream was patched a couple weeks ago, still nothing on either.
It seems particularly crazy for Ubuntu given that Debian released their fix something like a couple weeks ago.
They pull from Debian unstable every 6 months and that's it. Afterward, changes made in Debian mean nothing to Ubuntu.<p>Don't trust Ubuntu's LTS promises, either. Most of the modern packages you care about are in universe, which almost never gets patched after the initial release.<p>I think they deliberately leave the free LTS version insecure in order to sell Pro licenses. But guess what, even Pro doesn't get timely patches.
It's one of two things: Either they have found some regression with enterprise customers, or they are not happy with the fix.<p>RHEL runs with MP-TCP disabled by default, they initially listed it as Important only to later raise it to Critical.
I don't think I can recall an instance where there was an issue this bad (a box being vulnerable just by virtue of being connected to the internet, or exposing nothing other than ssh) and I didn't have timely patches for it. I had to turn off my server and home automation system because of this. Really not acceptable at all and makes me want to switch everything to debian.
>How are Ubuntu and RHEL not fixed?<p>IMNSHO this makes them unfit for purpose. I think this is the nail in the coffin for Ubuntu for me.
It's not a good look.<p>I pulled in from -proposed this time.<p>Ubuntu was slow on the brotli / CVE-2026-111497 updates as well.
What would you suggest for enterprise use of Linux if RHEL is no longer fit for purpose?
I'd be seriously considering Debian or, hear me out, NixOS. We run all our work servers on Ubuntu, but ~6 months ago I switched my workstation to NixOS and I couldn't be happier. I've been following "latest" or whatever they call it, being able to treat the OS package versions like the rest of our software (update the flake.lock file and then burn it in in dev+stg for ~2 weeks before rolling to prod) is pretty attractive.
Going by the proxmox forum the fix is already in the sources (proxmox released their kernel based on them a few days ago). But I could not see, if it is already released for the users.<p><a href="https://forum.proxmox.com/threads/cve-2026-98432-in-proxmox-ve.187339/" rel="nofollow">https://forum.proxmox.com/threads/cve-2026-98432-in-proxmox-...</a>
Yes, we (Proxmox) included the fix for this in 7.0.14-25, which was initially packaged two weeks ago.<p>It went through internal QA and to the test soon after that, then a few days later to the no-subscription repository and as of yesterday morning CET it was cleared for the enterprise one, so it's available on all repos of all Products we got in their current supported releases.<p>For kernel updates we where even more conservative in the past, but with the current churn on often quite relevant fixes picked up the pace a bit on moving them along, trying still to balance rolling out fixes fast(er) while not doing that so fast that tricky (hardware/setup specific) regressions don't get caught.<p>edit: As this makes the rounds we also released a PSA for it now [0] to make our status here easier to find.<p>[0]: <a href="https://forum.proxmox.com/threads/proxmox-virtual-environment-security-advisories.149331/page-5#post-874674" rel="nofollow">https://forum.proxmox.com/threads/proxmox-virtual-environmen...</a>
Running regression tests I assume; they can't just YOLO shit like most OSS projects for the exact reason you mention.
the default in RHEL/CoreOS is:<p>sysctl -a | grep net.mptcp.enabled
net.mptcp.enabled = 0
No patches for Ubuntu or red hat yet.<p><a href="https://ubuntu.com/security/CVE-2026-98432" rel="nofollow">https://ubuntu.com/security/CVE-2026-98432</a><p><a href="https://access.redhat.com/security/cve/cve-2026-98432" rel="nofollow">https://access.redhat.com/security/cve/cve-2026-98432</a>
Interestingly, Ubuntu Priority is set to "High" and not "Critical" which is defined as:<p>"A significant problem, typically exploitable for nearly all users in a default installation of Ubuntu. Includes serious remote denial of service, local root privilege escalations, local data theft, and data loss."
> <i><a href="https://ubuntu.com/security/CVE-2026-98432" rel="nofollow">https://ubuntu.com/security/CVE-2026-98432</a></i><p>The listed kernels are in the "proposed" component (and not yet in "security" or "udpates") if you want to pull them down onto canary systems for testing before going to production.
so just block multipath and add the firewall rule from article that drops packets with IPv4 options
Both of which we are finding out are apparently insufficient to mitigate this.
"the bug sits in code every Linux server runs when it accepts an IPv4 TCP connection, before any application sees the connection."<p>Is iptables considered an "application" here? I.e. can this bug be triggered before iptables drops the packet?
Hoping fix will be out soon so we don’t have to.
It's okay guys, the authors simply don't know how to write good C. A real C programmer would not have shipped such a basic use-after-free bug. Rust is just a crutch.
The fallacy is the idea that a Rust implementation would automatically achieve the same performance, and not resort to "unsafe" to be competitive, and then be open to exactly the same issues.<p>Illustrative example: This CVE in a Rust matrix transpose code: <a href="https://github.com/advisories/GHSA-5gmm-6m36-r7jh" rel="nofollow">https://github.com/advisories/GHSA-5gmm-6m36-r7jh</a><p>Conceptually, there is not really anything much simpler than a matrix transpose. So how did they manage to create a bug? To make it fast you need simd, which implied using unsafe, and the dimension check to make it safe used unsigned integers that could wrap around. So they same bullshit as in C.
Your fallacy is that you present the comparison 'if' either of the two can be done poorly.<p>Rust can separate the question: "Is a set of functions is safe in a certain condition" from "using functions in that condition".<p>They are materially different. SIMD has a safe interface now.
Google already did it and resorted to unsafe rust to be competitive.
I won't comment on your entire comment, but this:<p>> To make it fast you need simd, which implied using unsafe<p>Is just false. There are multiple safe SIMD libraries for Rust that can exploit the full SIMD potential. Only very rarely they require unsafe for maximum performance and only to avoid bound checks.
With all the "Claude rewrote X in rust!" posts lately, I'm waiting on the inevitable Linux kernel rewrite post.<p>Vibe code aside I feel targeted rewrites are becoming more and more justified.
Counterpoint, more than memory bugs exist, and everything's written in C. You're welcome to rewrite in Rust but you'll create countless bugs that aren't memory bugs that mostly already got fixed in the C version. I can't help but think things like fil-C are the most pragmatic route, despite performance costs, for most people relying on programs written in C.
Yes, you'd introduce a lot of new bugs because the code is newly written[1], but eventually you'll get to the same maturity as today <i>except</i> you can't have all these devastating memory-handling-related vulnerabilities<p>The question is whether your software will be in use long enough to be worth the cost of change more than whether it's a good idea in the long run. For Linux, I'd argue that that's likely. At least new code would ideally be contributed in a safe language, where practically possible (there'll surely be places where you need to deal with memory as a kernel)<p>Relevant article: reducing memory vulnerabilities through a combination of memory-safe languages and an exponential decrease of bugs as existing code ages <a href="https://security.googleblog.com/2024/09/eliminating-memory-safety-vulnerabilities-Android.html" rel="nofollow">https://security.googleblog.com/2024/09/eliminating-memory-s...</a>, from which I'll also quote my reference for [1]: "A large-scale study of vulnerability lifetimes published in 2022 in Usenix Security [...] found that the vast majority of vulnerabilities reside in new or recently modified code"
This is a dumb argument imo. Critical vulnerabilities are mostly due to memory bugs (and not for a lack of other kinds of bugs). Most people relying on programs written in C (or even C++) should consider plans for migrating to software created with toolchains from this century. You cannot indefinitely carry on this tech debt.
Here are some CVEs identified in Rust coreutils [1]. These are mostly really trivial issues. I'd bet money that the nastier logic bugs are still in there and that the people who maintained the old C utils or helped identify the old bugs can find similar ones in these utils, although half these issues probably never appeared in the C version because Rust is much more complicated than C so makes it easier to hide logic bugs in plain site, looking at many of the issues in this article they seem like bugs that are extremely unlikely to get written in C, like accidentally forcing everything to be UTF-8, or aborting on routine errors.<p>[1] <a href="https://corrode.dev/blog/bugs-rust-wont-catch/" rel="nofollow">https://corrode.dev/blog/bugs-rust-wont-catch/</a>
I strongly disagree with the idea that Rust makes it easier to hide logic bugs. Rust is a much more complicated system than C but allows software engineers to work at a much higher level of abstraction which generally reduces logic bugs. Of course, new projects will inherently have bugs but with Rust it is easier to achieve a higher level of rigor.<p>To be clear, this is not due to the borrow checker at all, Rust does not have the tooling to statically determine the absence of logic bugs. What it has is the necessary programming language features to manage much more complex systems through abstraction and modeling.
At least it doesn't silently launch nuclear rockets, smaller bugs are manageable, like accidentally forcing everything to be UTF-8 is basically nothingburger.
One issue with this argument is that, almost everything is memory, especially in C. It's not really descriptive. If you write a reactionary language like Rust, it may be possible that you just fix one type of issue (with an error type taxonomy that's not very refined), and end up with a language that does not necessarily cause less bugs and vulns, but that causes less vulns that can be classified as that type of issue, while increasing other types of bugs/vulns, either of an existing type, or of a new type that only exists in that new language.<p>Like are we empirically seeing less Rust CVEs? Adjusted for popularity of software and perhaps age of software.
Are you saying by attempting to reduce certain types of bug category such as memory safety, other types of vulns would suddenly be increased because of it? It sounds to me like you are saying we shouldn't treat common cold because cancer rates might increase. And what do you mean by reactionary?
It’s also never been easier to replace C programs with safe alternatives.
I'm not suggesting anything like "rewrite in Rust", at least not in general. I'm simply poking at the fact that use-after-free (and other such issues) are effectively deprecated classes of bugs.
At least if you’re on Amazon Web Services behind a load balancer you probably aren’t really that impacted enough to spend Halloween patching.<p>> AWS Web Application Firewall, Application Load Balancer, Classic Load Balancer, TLS Listeners on Network Load Balancer, Cloud Front, API Gateway<p>> Customers using the above services do not receive TCP connections from untrusted sources directly when following best practices. AWS is applying updates to the underlying infrastructure of these services and no immediate customer action is required if you are using these services. We still recommend customers update their self-managed instances behind these services within the next 30 days.<p>[0]: <a href="https://aws.amazon.com/security/security-bulletins/2026-160-aws/" rel="nofollow">https://aws.amazon.com/security/security-bulletins/2026-160-...</a>
I'm more worried about my consumer-grade router.
I switched to OPNsense last week. Consumer grade WiFi AP is behind it. I’m not depending on firmware updates from a company that has no incentive to make them.
May CGNAT save you.
I blocked packets arriving externally on my firewall with ip-options a couple of days ago. Firewall rule has zero hits, and I've got a very open ISP (andrews+arnold), if I want I can host SMTP, DNS, whatever
The timeline says the CVE was reported over 2 weeks ago, so why are the alarms sounding now?
For some reason the submission I saw here last week (not the same article, and I'm struggling to find now) was flagged to death before getting as popular as this one.
Anthropic published a blog post claiming RCE with it [0].<p>[0]: <a href="https://www.anthropic.com/research/discovering-vulnerabilities-with-claude" rel="nofollow">https://www.anthropic.com/research/discovering-vulnerabiliti...</a>
Note: AWS NLB doesn't terminate TCP for TCP listeners.<p>It would be great if they introduced mitigations for this vulnerability though.
Another reason hyperscaler cloud providers will continue to grow (IMO)!
My FreeBSD loadbalancers block packets with IP Options with default config. It’s not rocket science, no matter how Cloud providers are trying to tell us.
Unless they themselves (underlying services) get hacked...
My VPS was auto-updated and restarted more than 14 days ago. The logs have rolled already. Probably October 12 early morning.<p>Another reason NixOS will continue to grow :)
Everything talks about this in terms of servers, but what about desktop Linux in typical setups? Consumer modems and routers? IoT junk?
IoT devices will get fixes delivered on the 12th of never.
So, the good news is that I can probably now get root on almost any Linux-based device I own. Don't even need to solder on a serial port or w/e, just direct network connection.
Yeah this is really a blessing for people seeking more control over nice hardware with horrible software, "smart" spy TVs, Android (moar ads on your) TV boxes, cheap insecure security camera's with only Crappy Cloud subscriptions... Go AI!
Needs two cpus at least, so a lot IoTs are spared because of that
But are they exploitably vulnerable to this specifically in typical setups?
The security fixed will be installed next tuesday.
Was going to say that, depending on the device's age, this law may apply, where article 13 sub 9 specifies a decade of updates is the minimum: <a href="https://eur-lex.europa.eu/eli/reg/2024/2847/oj" rel="nofollow">https://eur-lex.europa.eu/eli/reg/2024/2847/oj</a>
But then it turns out that this "applies from" late 2027 :/<p>Simultaneously Wikipedia says the Act has "entered into force" in 2024. Does anyone know the difference between "enters into force" and "applies"? Is it like this 2016–2018 grace period for GDPR where it was "law" but not enforced? (The wording sounds backwards if it's that, but I'm not a native speaker)
That's how i'd read it but i'm not 100% sure. legal terms can have specific meanings in a legal context that's different from general use.<p>but also this is one of those cases where, ok you have a law, but, that's meaningless. It's not enforceable. It's not even monitorable. It's nice in theory to write down a bunch of regulations but at best you can make a bunch of EU companies do some paperwork. anything imported from outside the EU, the company can agree to everything and then dissapear. ALl the direct to consumer slop on amazon and whatever. How is the EU supposed to enforce a law against a random fly by night brand name in Shenzhen?<p>From <a href="https://taxation-customs.ec.europa.eu/news/report-highlights-need-stronger-customs-controls-and-cooperation-protect-eu-citizens-and-businesses-2026-07-20_en" rel="nofollow">https://taxation-customs.ec.europa.eu/news/report-highlights...</a><p>> As volumes rise, enforcement is weakening. In 2025, the EU control rate fell to 65 items per million items imported. The rate of goods ultimately refused at the border due to non-compliance or because they posed serious risks, also fell to below 10 items per million.<p>> A large-scale customs investigation launched by the Commission in 2025 highlights the scale of the problem. Over 60% of checked toys, small electronics, cosmetics, personal protective equipment and food supplements bought online from outside the EU failed to meet EU product compliance and safety requirements.<p>It's just regulation theater. It's meaningless.
You should assume your IoT junk is already compromised, that's why your IoT junk runs on a dedicated VLAN.
What kernel is the router managing these VLANs running?
They're on a dedicated VLAN in the county dump
Desktop Linux in typical setups? Consumer modems and routers?
I think fix arrived like two weeks ago or something. So typical Desktop Linux is safe. I use Arch btw
I've been compiling a list of cybersecurity RSS feeds to build a small automation (with oversight from Hermes agent) to ping me (ntfy.sh or just Telegram) when a CVE requires my intervention (matching them to a list of services I run for clients and myself.)<p>My list (of feeds) is still small, but this CVE did not show up, do any of you have any tips for RSS feeds to use for this purpose?
<a href="https://pwn.watch/" rel="nofollow">https://pwn.watch/</a> has an RSS feed available
Any chance you’d mind sharing your list?
From Claude:<p>_If you’d rather get messages in real time, you can subscribe to the list itself by sending an empty email to oss-security-subscribe@lists.openwall.com. Be aware that the volume is high; October 2026 alone had 460 messages._<p>That's also well into clanker managed territory ;) (I mean the clanker builds a small automation, no LLM involved after that, I do a lot of that, just use clanker to build, update, organize, monitor and handle edge cases.) I have used free (and therefore limited) agentmail.to for this. I find the subscription to be a bit expensive for my hobby, but it's a nice service if you do this professionally.
[dead]
The openwall oss-security list usually covers a decent number of issues and this CVE was mentioned there yesterday:<p><a href="https://www.openwall.com/lists/oss-security/" rel="nofollow">https://www.openwall.com/lists/oss-security/</a>
Thanx, the relevant rss feeds seems to be presented here: <a href="https://seclists.org/oss-sec/" rel="nofollow">https://seclists.org/oss-sec/</a>, being <a href="https://seclists.org/rss/oss-sec.rss" rel="nofollow">https://seclists.org/rss/oss-sec.rss</a>
Linux noob: I run a small VPS for a low stakes side project that runs Caddy and a Go backend that I've shutdown for precaution. Once a Ubuntu patch is made available, I read that applying the patch and reboot will be enough, but how can that be the case if someone used the exploit to break in and leave a rootkit or something like that? What are your full recovery plans for these situations?
If you don't already know and need to be sure, you have to start over with new hardware in a new network with new secrets. Firmware may be compromised and traces covered up, so reinstalling the operating system is not guaranteed to get the attacker out, nor can you trust the system to tell you if it was compromised or not. Your best bet would have been to record all incoming network traffic to a system only accessible offline and use it to verify no one tried to get it. Otherwise you can just hope, which is what mostly everyone will do, and will mostly be alright, because they're not important enough.
If you run caddy it's written in go so probably listening on an mtcp socket meaning you are probably vulnerable. Watch out!
> Anthropic says Claude wrote the exploit "after initial prompting," that it runs "arbitrary commands as root, without any credentials or user interaction" on servers with a multipath TCP listener, and that in its proof of concept "it takes 48 minutes to leak a kernel pointer and another five minutes to reach the shell command execution."<p>This is wild. I'm a firmware nerd, not a backend nerd, what percentage of TCP/IP servers are 'multipath'?<p>Also, since IPv6 isn't affected, wouldn't it be funny if this is what it took to get everyone to switch.
> what percentage of TCP/IP servers are 'multipath'?<p>no idea, but at least Tailscale and Caddy were opening MPTCP sockets on servers I checked.
only if it's enabled at the kernel level?
I have this, and it's the defaults, on my RHELs:<p>sysctl -a | grep net.mptcp.enabled
net.mptcp.enabled = 0<p>and found not MPTCP listeners anywhere, including where I have caddy.
My understanding is that an app explicitly needs to open a "multipath" socket. Go 1.24 does that by default, so does Caddy, these would be the big ones.
Can anyone explain how use after free results in a practical exploit?<p>I ask because I’ve been dabbling in rooting various closed devices at home. I’m finding AI fantastic at finding vulnerabilities statically (from firmware upgrade binaries), but when you then ask it to use it to get root or code execution it just goes in circles.<p>In the end it usually ends up there’s no exploit it can find, because it can’t actually influence the affected memory in a useful way. This is especially so if that memory is in the heap. On the stack it’s a lot more predictable (especially with OOB writes).
You need to do some <a href="https://en.wikipedia.org/wiki/Heap_feng_shui" rel="nofollow">https://en.wikipedia.org/wiki/Heap_feng_shui</a>. If you can reasonably reliably trigger some other operation that allocated the freed memory for another purpose, you have something like a type confusion vulnerability.
One example is that you might be able to read what was written there. Here that may mean you could read another process’s packet(s). Imagine they were sending unencrypted passwords, perhaps because it’s in a trusted LAN connection.
If it’s freed it can be reallocated, so then you have pointers to the same area of memory used for completely different data structures, and this can go very wrong
I get the principle - what I struggle to find is concrete examples of how it can practically be used.<p>How do you know <i>which</i> pointer (as I say, especially if it’s in the heap)? And I know it can go wrong - but how do you do more than just crash the kernel?<p>In OOB writes in a stack variable it’s completely clear to me. For other situations I’d love to find real and clearly explained exploits of past UAF or OOB vulnerabilities.
Getting the right thing allocated in the right place to exploit a UAF is usually very very tricky. For a defender we just need to know it's probably possible and therefore we patch the bug, but the attacker still has a difficult job to do even already knowing a UAF bug.<p>The simplest thing you could try to do is allocate several more of the same type of object and hope one of them lands at the same memory address. For example if you can UAF a web app's user session and keep it open for a long time period (not true in the TCP bug), you might try to wait until an admin happens to log in with their session at the same address, then use their admin session.<p>Or you can allocate a lot of something else objects and hope a certain field overlaps, like a function pointer if you can write to it. Like suppose you can get some kind of authentication callback pointer to overlap where your packet sequence number was, maybe you can send a certain number of packets to make it point to the return instruction and skip the authentication.
One technique is to just spam the heap full of a certain object you're hoping will overlap it. E.g. if you want to affect a connection object, you might try to open one million simultaneous connections, then touch the UAF object, then check each connection to see if it got messed up. This is called heap spraying and it's often seen in JavaScript vulnerabilities, a bit less in network vulnerabilities since it's easier to allocate a million Uint8Arrays than to open a million TCP connections.
A web search for "exploit chain uaf" found me a few real-world and a few tutorial examples, though I don't know which are good.<p>At a high level, though: once you've gotten a new object allocated where the old one was, you now have two different views of the same bit of memory. You use valid operations on one view to put the other one into a corrupted state. For example: in a unixlike kernel, maybe one view has a field containing a function pointer (for method dispatch, essentially). You read that field using the other view, use it to deduce something about the target's memory layout, write a new value to the pointer, then use the field via the first view to cause execution to jump to a location you control.
Maybe check <a href="https://github.com/sarabpal-dev/IonStack-S22U" rel="nofollow">https://github.com/sarabpal-dev/IonStack-S22U</a>
It has a full chain reproduction of the use-after-free vulnerability that grants you root on Samsung phones with a locked bootloader.
I don't think a UAF on its own allows control hijacking in an exploit. You will need further logic bugs or the ability to legitimately or illegitimately control memory, either via further requests / function calls, OOB writes and such. And it will always be extremely specific to the application vulnerable.<p>For example, I remember an exploit workshop around reuse of passwd entries. The vulnerable would validate a passwd entry for a non-root user, use it a bit, and later on free and zero it out for security purposes... except it then looked at the passwd entry again in some conditions. Suddenly, the uid was non-zero at first, and zero later on, so later decisions assumed the user was root.<p>In a more concurrent situation, a possible vulnerability was a shared cache of these passwd entries. It wouldn't zero them out anymore, but you could create a race condition of starting requests as user A, and then hammering requests as user B, so you'd end up mixing up the permission contexts of these users. Because the passwd entry that had been released back to the pool was overwritten, and then re-read with the value from another context.<p>The necessary line of thinking tends to be very different from thinking about program code regularly.
Out of interest - what models are you using for this? GLM?<p>From experience OpenAI and Anthropic have pretty heavy safeguards in recent (public) models.
It goes around in circles because a UAF alone isn't enough in a lot of cases, sometimes you also need a chain (an info leak, read/write primitive etc), a way to defeat ASLR and so on depending on what you are working on and target mitigations. Not all UAFs can be used for RCEs, some can be used only for DoS or for nothing really.
been doing exactly this lately with camera firmware and yeah the circles thing is real, but im pretty sure its a feedback loop problem, not a model problem<p>the model spins because it cant test its own guesses. what fixed it for me was emulating the actual device. qemu with the vendor rootfs, real binaries running, and then every claim becomes checkable: did the daemon actually parse my input, which uid is it under, what does its own log say. once it can check things it stops guessing, getting qemu to actually boot the thing was its own little hell though, took more tries than i want to admit.<p>the other thing i learned the hard way: most static findings die on reachability, not on exploit primitives. so i run them in the emulator first and kill the unreachable ones cheap, before spending any time on heap work<p>on heap vs stack, i think that intuition is desktop shaped. device userland usually has weak or no mitigations, heap uafs are way more tractable there than youd expect
If you really learned anything you should post <i>your own</i> thoughts, not whatever this lowercased Claudish is.
Oh yes definitely seen the reachability problem!<p>Good ideas on the QEMU. I guess you’d have to patch the binary if it’s expecting particular hardware etc?<p>Not sure what you mean by “desktop shaped”?<p>Can you give a concrete example of UAF on heap? I’m learning a bit on how this is done, and eventually recognised the LLM is doing something called heap spray. But that seemed to rely on hoping some object you wrote just happened to get interpreted by some process. And that was the “no, wait, pointer f isn’t y” loops.
I suppose I'm not the only one feeling worn out by this tidal wave of vulnerabilities that I somehow have to keep up to?
The good news is, if you emergency patched your Debian for php2shell, you probably got the new kernel on the same apt run. This time the embargo actually held, and the new kernel was out before the CVE came public
Nope. This was just the start.
Fixed upstream in:[1]<p>7.3 (2026-10-18)<p>7.2.10 (2026-10-11)<p>6.18.56 (2026-10-11)<p>6.12.113 (2026-10-15)<p>6.6.159 (2026-10-15)<p>6.1.190 (2026-10-15)<p>5.15.225 (2026-10-15)<p>[1] <a href="https://lore.kernel.org/all/?q=tcp_v4_reqsk_destructor" rel="nofollow">https://lore.kernel.org/all/?q=tcp_v4_reqsk_destructor</a> -- check for "kfree_rcu" being used instead of "kfree" within "tcp_v4_reqsk_destructor" (net/ipv4/tcp_ipv4.c)
This saddens me since MPTCP is quite useful and not the cause of the bug, just a way to ease exploitation (probably simpler heap massaging? Way over my head). Anyway, upgrade, but don't block MPTCP; no exploit is available, and it's just as likely someone finds another path before Anthropic releases theirs.
god this page could hardly be more ai generated if it tried<p>actual link: <a href="https://nvd.nist.gov/vuln/detail/cve-2026-98432" rel="nofollow">https://nvd.nist.gov/vuln/detail/cve-2026-98432</a>
I am surprised formal verification efforts of the Linux kernel didn’t find this. Any experts care to chime in?
>the kernel handed those saved options from the request socket to the new connection without copying them, then freed them immediately when the connection went away, while another CPU could still be reading them to build a handshake reply.<p>If this requires a multi-core system to exploit, it's good news for most of the consumer routers that will never get updates. Saved by cheap single-core hardware.
You would be surprised. A lot of cheap consumer routers are have two or four ARM cores. The bigger issue is that they are typically running a kernel from the stone age (< 6.0.0). Sometimes a still-supported LTS kernel like 5.10 or 5.15, but then they stopped at an old patch level.<p>Heck, apparently even the new Unifi UCG Fiber is running 5.4.213 (September 2022), but maybe they backport some fixes?<p>[1] <a href="https://community.ui.com/releases/dd0283dc-bf71-4140-ae1d-c1c19503ac17?replyId=ee1fc17f-6a78-43d2-93f6-6d5228758187" rel="nofollow">https://community.ui.com/releases/dd0283dc-bf71-4140-ae1d-c1...</a>
Note that even the latest OpenWRT is vulnerable to this, I'm running OpenWRT 25.12.6 and the kernel version is 6.12.112
I’m in the market for a new router. Got a unifi u7 pro for wifi already, what are the options for routers? Sounds like the only safe thing is to roll your own so you can update things on time.
If you wants something with a nice web interface, probably OpenWrt [1] or OPNsense?<p>[1] Yes, it seems that they are still on 6.12.112, but they'll probably roll out an update quickly. Also see: <a href="https://forum.openwrt.org/t/cve-2026-98432-kernel-update-or-backport-planned-for-openwrt-25-12/254971/12" rel="nofollow">https://forum.openwrt.org/t/cve-2026-98432-kernel-update-or-...</a>
If you have a separate WiFi AP running your own router on your *nix of choice is quite achievable. I use NixOS since I use it everywhere else, if I didn't I'd probably go with OpenBSD.
My $50 router has two cores.<p><pre><code> root@OpenWrt2:~# lscpu
Architecture: mips
Byte Order: Little Endian
CPU(s): 4
On-line CPU(s) list: 0-3
Model name: -
Model: MIPS 1004Kc V2.15
Thread(s) per core: 2
Core(s) per socket: 2
Socket(s): 1</code></pre>
Those routers probably have 20 other critical un-patched exploits ...<p>An entire ecosystem of malware crawling and cohabiting in them.
My home firewall runs Ubuntu. It doesn't accept (new) incoming packets from the internet. I don't have any IoT devices except printers, whose packets the firewall rejects, and has done since I bought them. Do I need to do anything apart from wait for the patch to become available?
Is OpenWRT affected? Because that would be a real fawkin problem.
OpenWrt doesn't open ports by default so I think the impact is minimal, unless this can breach nftables as well. CGNAT also mitigates this as a side effect.<p>If you have services open on the IPv4 net however, close them immediately as a precaution.
As much as I hate to link to this site, this particular sub is very good:<p><a href="https://www.reddit.com/r/openwrt/comments/1xka85h/is_the_openwrt_update_frequency_fast_enough_in/" rel="nofollow">https://www.reddit.com/r/openwrt/comments/1xka85h/is_the_ope...</a><p>They say 25.12-SNAPSHOT has it fixed
Who says that? Please link the exact comment.<p>Edit: I see now which comment you mean:<p><a href="https://www.reddit.com/r/openwrt/comments/1xka85h/comment/19rxk3zewybs1/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button" rel="nofollow">https://www.reddit.com/r/openwrt/comments/1xka85h/comment/19...</a><p>The `-SNAPSHOT` build is the pre-release build.<p>More details below:<p>Apparently for the Linux 6.12 series that OpenWRT uses it's only fixed in 6.12.113 (see <a href="https://news.ycombinator.com/item?id=50322061">https://news.ycombinator.com/item?id=50322061</a>).<p>But the latest OpenWRT release has an older version, 6.12.112, as per <a href="https://openwrt.org/releases/25.12/changelog-25.12.6" rel="nofollow">https://openwrt.org/releases/25.12/changelog-25.12.6</a>. And the release notes <a href="https://openwrt.org/releases/25.12/notes-25.12.6" rel="nofollow">https://openwrt.org/releases/25.12/notes-25.12.6</a> do not mention CVE-2026-98432.<p>I checked OpenWRT git (<a href="https://git.openwrt.org/openwrt/openwrt/log/?h=openwrt-25.12" rel="nofollow">https://git.openwrt.org/openwrt/openwrt/log/?h=openwrt-25.12</a>) and the commit "kernel: bump 6.12 to 6.12.113" is only 40 hours old, and NOT released in an OpenWRT release: <a href="https://git.openwrt.org/openwrt/openwrt/commit/?h=openwrt-25.12&id=8303e9b2a004a6c3754aaa1edb32cfc7c0cfe55b" rel="nofollow">https://git.openwrt.org/openwrt/openwrt/commit/?h=openwrt-25...</a>
Weird, front page >500points today; flagged to death last week.
Without a test-case, read POC, how do I verify if my server is affected?
What is a "multipath TCP listener"?
A listener is a piece of software that advertises itself as available to inbound connections. You can do this on a variety of protocols.<p>Multipath TCP is a neat trick that allows a single TCP connection (TCP = Transport Control Protocol, a stateless protocol for long running connections) to use multiple physical interfaces. You <i>could</i> do something similar before MTCP using bonding, but this was annoying to set up and usually required application level code to efficiently use the bonded connection. MTCP makes this much simpler from an application level point of view and it can use widely diverse underlying transport layers at the same time (for instance, WiFi, Cellular and wired connections).
> Transport Control Protocol, a stateless protocol<p>TCP is stateful by definition, and that is why it supports robust error correction and reliable streams of data. UDP is its stateless counterpart.<p>> bonding, ... usually required application level code<p>No, it doesn't. <a href="https://en.wikipedia.org/wiki/Link_aggregation" rel="nofollow">https://en.wikipedia.org/wiki/Link_aggregation</a><p>> underlying transport layers<p>TCP <i>is in the transport layer</i>! The layers which you name are lower, such as Layer 2 (Data Link)!<p>MTCP, being in the transport layer, is working at a higher level of abstraction than bonding or link aggregation. There is no need for application-layer support, but it is possible, and easier, with MTCP than with the Layer 2 solutions, because MTCP is in the transport layer. That is why Go was able to activate it, and the POC uses it, because MTCP controls can be exposed at that level.
AI slop reply
See <a href="https://en.wikipedia.org/wiki/Multipath_TCP" rel="nofollow">https://en.wikipedia.org/wiki/Multipath_TCP</a><p>It's an extension to TCP that, similar to QUIC, allows you to use multiple address/port pairs to transmit data over a single logical stream. Both client/initiator and server/listener have to opt into the extension. This might need to be enabled explicitly by the application[1], which Go apparently does for you, or judging from other posts may be enabled by default systemwide, depending on your platform.<p>AFAIU, a major user of MPTCP is Apple and the iPhone, and the ubiquity of iPhone clients motivated implementation in and deployment on Linux servers.<p>[1] <a href="https://docs.kernel.org/networking/mptcp.html#sockets-api" rel="nofollow">https://docs.kernel.org/networking/mptcp.html#sockets-api</a>
I had to look it up too since I hadn't heard of it. It's an extension to TCP that allows responses across different NICs. Sort of like Link Aggregation on to a switch, except it can go out dissimilar interfaces, like your wifi connection and your hardwired connection. Looks like you have to opt into it when you set up your socket: <a href="https://docs.kernel.org/networking/mptcp.html" rel="nofollow">https://docs.kernel.org/networking/mptcp.html</a>
You have a Wifi network interface and a wired Ethernet one, multipath is somehow combining the two together.
In addition to aggregating, it can also be useful in cases where one link is much slower or higher latency. For example, if you're sitting in your driveway trying to get directions in maps while your phone is still on your very weak wifi network, it's a better user experience to have it to attempt the request using both radios concurrently so that it can fallback to cellular without waiting for a timeout/connection error if you're too far for wifi to actually work well.
Some previous discussion: <a href="https://news.ycombinator.com/item?id=50299182">https://news.ycombinator.com/item?id=50299182</a>
The linked source spun up my fans with 100% GPU utilization. Is there some... unwelcome... script running?
If you’re on Ubuntu you can upgrade by pulling the -43 version from the -proposed repo. Crazy they still havent shipped it to -stable.
This particular page (and other pages at altasum.net) is a CPU hog.<p>It usually means: suspicious activity or poor taste or disregard for web standards, or a combination of these.<p>There is a plenty of information on that CVE from other places.
I was sorely tempted to fully bypass the kernel for networking before, and this isn't exactly giving me warm fuzzies for staying.
> Anthropic says Claude built a remote root exploit for servers with a multipath TCP listener. It hasn't published the exploit.<p>Bro, we've gained a root RCE with this vulnerability. No, you can't see a PoC, just trust me bro, we have a root RCE, also buy our IPO pls bro.
2027 is going to be the year of two to three major CVEs per day.<p>The discourse on this is weird, sounds at times as if these are “because of AI.” These are mostly pre-existing bugs, some very old, and they’ve been lurking. If they all get found we exit the other side more secure and reliable.
I went on a security kick early this year, locking down everything as much as I could. Build your systems with the assumption that you WILL get hacked. Limit blast radius. Be prepared.<p>The next few years will be crazy, but you're right, we'll come out the other side more secure than ever before. Just gotta make it that far!
> If they all get found we exit the other side more secure and reliable.<p>I agree, but as yet we have no idea how much pain we have to pass through to get to the other side.
I wonder if switching to openbsd for my servers soon might be a good idea...
On the other side we have a Linux networking stack written in Rust.
What does this enable an attacker to do exactly? RCE? DoS? Unknown?
If you run a custom kernel chances are you're not affected:<p># CONFIG_MPTCP is not set
There is zero context, zero information, very alarming language but nothing about mitigation factors.<p>This is a terrible way of communicating vulnerabilities.
MikroTik routers seem affected but mitigations are available.<p>Watch your Linux systems for kernel updates. Reboot!
Finally a usecase for mptcp on linux. Been waiting and trying off and on for years to get it to do something, but now it can give a nice remote root shell. Well, not to me, I just get to patch devices.
There are microkernel operating systems out there that run the network stack in isolated, unprivileged contexts. Some of them are even not written in C.
The most terrifying part of this is all the devices that might be affected. Ignore servers and desktops. Linux 4.4 came out nearly 11 years ago. While most Linux devices' firmware is actually more ancient than that (Linux 2.x and 3.x isn't uncommon), any device that <i>did</i> ship with Linux 4.4+ is going to get hacked, because nobody patches those devices. Any smart device in the world that isn't a server, desktop, or microcontroller, is probably running Linux.<p>As part of the Software Building Code (that we don't have, and desperately need), one of the things we should have is mitigation for these abandoned internet safety risks. Here's how I would define that section:<p><pre><code> Section 4 Connections to Public Internet
Section 4.1 Device Support
Devices connected to the public internet WILL require one of the following:
a) Guaranteed LTS support for a minimum of 10 years
b) Guaranteed rolling release support for a minimum of 10 years
Devices without this support are not permitted to be connected to the public internet.
Section 4.2 Vendor Responsibility
When releasing devices, vendors must determine whether this device is certified for
public internet use. Support must be maintained according to S4.1. Failure to comply will
result in fines of up to $5,000 per affected device.
Section 4.3 Installer Responsibility
Any device connected to the public internet which is not certified for public internet
use is in violation, and will be subject to fines of up to $500 per affected device.
Section 4.4 Device Owner Responsibility
Any installed devices will be replaced once they reach their End Of Life period,
or after 10 years, whichever comes first. Installed devices in use that exceed this
period are in violation, and subject to fines of up to $250 per affected device.
</code></pre>
(These fines are tiny compared to the fines for things like fire code violations, but enough money that a company, contractor, or individual would rather fix their device than pay the fines)
If I am reading this right, Slackware 15.0 is already fixed:<p><pre><code> % uname -a
Linux XXXX 5.15.223 #1 SMP PREEMPT Thu Oct 22 00:03:07 CDT 2026
x86_64 Intel(R) Core(TM) i7-4810MQ CPU @ 2.80GHz GenuineIntel GNU/Linux</code></pre>
Is Traefik affected?
I tried to find a mitigation using a ufw filter that rejects IPv4 packets with too large headers but it didn't work. It broke something essential and I had to switch it off again. I'd be interested in hearing about a temporary mitigation using firewall rules.
[06:00]
Nothingburger as per usual
Oh joy.
[dead]
[dead]
Let me guess... The bug is in C code?<p>(reading TFA)<p><pre><code> net/ipv4/af_inet.c
net/ipv4/tcp_ipv4.c
</code></pre>
Ah yup.<p>And moreover it's a security issue found by LLMs.<p>It's kinda a really bad time to be a C-loving, AI-hating, fanboi.<p>Do we at least entertain the idea that some rewrites of some things in safer languages could be a desirable goal? (not saying it's practical or not: just asking if C lovers are willing to reflect a bit on what's going on atm).
With only 0.5% of Rust code in the kernel, this does not say much. The binder thing seems to be the only real Rust component so far, and it also mysteriously already had a race condition despite it being impossible to do such mistakes in Rust.
Get rewriting, soldier!
maybe<p>i’d focus on writing new stuff with rust though, not rewriting old stuff<p>and time will tell whether it actually reduces bugs or just change the failure modes to something else<p>also C will always be there in some way or the other, at least in conventions and syntax
How are people finding Fil-C? It's designed to avoid things like this.
It might be bit of an effort to get Fil-C compiling the Linux kernel. As I understand it, it would amount to running garbage collector in the kernel, so some care would probably need to be taken to ensure it doesn't stop things at the wrong time, e.g. interrupts.
Does it support writing kernels?
Who wrote the bug? Very likely someone at Redhat.
In an earlier report, it said only affected is kernel 4.4, not all since. This quite dramatic now.<p>I see. <a href="https://nvd.nist.gov/vuln/detail/cve-2026-98432" rel="nofollow">https://nvd.nist.gov/vuln/detail/cve-2026-98432</a> affected versions format is the culprit. Entirely unusable.
We do have versions, branch names and tags for a reason.