@dymaxion @dalias
Most systems have options to only apply them manually, for folks who know what they're doing, but they're off by default because it's the wrong answer at the population scale.
Given how those settings are actively ignored?
No, they don't have such options. They have the illusion of such options.
How do you fix vulnerabilities without updating software?
Not making broken software to start with sounds like a good idea.
Having a system that doesn't default to ambient authority as well.
UX is an unavoidable part of software development.
So is user education if one wants anyone else but oneself to reasonably use it.
Defensive design doesn't fix everything, though — you will always have attack surface, and it will eventually have vulnerabilities.
That is both a hefty assumption and too imprecise to be useful.
Attack surface that requires unrealistic vectors for remote attackers (remote here being "without physical access" is perfectly possible). I would not consider that nearly as problematic.
There are ways to design schedulers so that the various CPU & memory bugs of the last decade are impossible to exploit.
We started doing automatic updates because if updates aren't automatic, they didn't get applied.
The excuse, at the time, was the dogshit design of Microsoft Windows having no package manager or any way of updating in a structured and reliable manner by the users.
The solution wasn't adding automatic updates and dropper capacity to every program.
The solution was moving off Microsoft's garbage or forcing them to fix it.
Third-party package managers are a nice effort but insufficient since their lack of official support means most programs ignore them.
A first-party package manager requires undue trust in an American company's goodwill & diligence, even with third-party repositories by more trustworthy parties (antitrust would be helpful here), but so does using their OS to start with.
Yes, there are times when malicious updates get applied. Our process for getting code to users securely is good in most places, but not perfect.
Bearing in mind that everything I wrote before still stands...
That only works when the call isn't coming from inside the house. Linux and Microsoft both push malicious slop patches now.
We're seeing more cases where software gets taken over. A lot of them happen because the teams don't have the resources to do better.
The impact those malicious updates have, in first or third party software, is in considerable part possible due to bad system design & architecture.
One can't even say Microsoft doesn't know better, they abandoned two superior OS designs that fixed a number of their problems but that never made it to market.
In part this is because the incentives are wrong for proprietary vendors. If they can remain profitable selling garbage, they have no reason to sell anything better. Particularly when they have an effective monopoly in various ways.
Though Google's Android has been eating at Microsoft's monopoly, but some malicious parties in Europe seem poised to make Google's a legally required monopoly.
Folks are working on adding better tools for detecting malicious code to update pipelines, but that's always going to need continuous work; it can't simply be fixed, because "malice" is a human interpretation of code.
Malice is a social dynamic. It can be embodied it code, in design, in UI, it doesn't require any code directly doing anything harmful in itself.
Gross negligence is frequently indistinguishable from malice. We see this with slopware and devs so readily adopting fashtech.
Large organizations quarantine updates and scan and review them before applying them.
Indeed, trusted parties, as chosen by the user are a valid mitigation mechanism for malice.
It could be made easier for individuals to do this too, but very few people want spend their evenings reading patch diffs, so there's no demand to make this easier.
There is such demand, but corposcum very much do not want to share designs & knowledge.
Just look at how much of Right to Repair is pulling teeth from hen (figuratively) and that's for rather mediocre results compared to what was just readily provided with one's electronics half a century ago.
Proprietary software should include the source and all the engineering documentation for users to fix it.
Hardware should include full specifications & firmware source. No NDAs, no bullshit.
There is demand and it is being actively resisted.