My guess: At some point in the past, a firmware was developed without plans to include firmware update functionality. The team that did this was later burned when the client tried to use a new certificate that the hardcoded, unchangeable system didn't recognize.
Angry meetings occurred, developers were chastised, and someone realized they could avoid that problem by fetching an updated root CA on demand. They did it over HTTP to avoid a chicken and egg problem.
In hardware manufacturing, everything is about crossing items off the list of problems. A problem was raised, someone came up with an idea to solve that problem, and it was implemented. The practice might have spread to other products because it became institutional knowledge about how to avoid a problem that made a customer angry once.
This is from my experience in the consumer hardware industry. If you're not watching the outsourced development closely, they will take the easiest route to solve the problem in front of them and nobody will consider any other consequences.
There is nothing wrong with downloading a certificate over HTTP. In fact, that's how PKI is designed and if you look at the AIA field of this very site you will see the certificate chain is meant to be served over HTTP.
What IS wrong is implicitly trusting an untrusted certificate. Whether it came over HTTPS or HTTP is irrelevant. But no one is talking about that.
I'm more puzzled why someone would buy a complicated IoT purifier for a drafty Bay Area house that probably has knob and tube wiring.
My most reliable air purifiers have a dumb, physical on/off switch. I bought them deliberately for that feature.
You publicly demonize something long enough and otherwise intelligent people start believing HTTPS is an invisibility cloak or the Good Housekeeping seal of approval for the web.
1) Others knowing knowing exactly which package you are downloading could give them a very clear way to fingerprint and target services you are running
2) HTTPS could allow you to potentially reduce your risk surface in a case where there is a bug in Steam's signature checker itself and someone sends a crafted payload instead of game files. Server validation would have prevented that. This has actually happened with apt before: CVE-2019-3462.
Odds are small, but I believe in DiD. I could imagine an attacker with nothing better to do could get up to this on say, a Uni's network.
And before you come at me with I should be using a VPN to protect against these scenarios, I do that already. This is about HTTPS being a sane default when possible.
Or they could connect to the service.
> Server validation would have prevented that
No it wouldn't have. HTTPS does not ensure a server's contents are trustworthy.
> And before you come at me with I should be using a VPN to protect against these scenarios, I do that already
So you protect yourself from unlikely, irrelevant threats by... deliberately paying strangers to MiTM your traffic?
The default for package upgrades on PCs should be (and is on Ubnutu and Fedora) HTTPS as it reduces risk with minimal performance impact for most of the people.
When building update systems, while you shouldn't root your trust in PKI you should still use HTTPS to make attacks harder because even if your updates are signed there is still a lot of parsing going on before you get to the update payload. (Even better, you should use TUF to avoid reinventing insecure designs.)
That's explained pretty early in the article, author wants to be able turn it up high to double as a noise machine from the same automation that turns off lights and such for nighttime
Solution: ignore security in 1st party code outside 3rd party library that tries to prevent ignoring security.
As far as I know, most of this cheap crap is basically supply chain management companies that contract a factory to manufacturer and contract a software development/IoT/chip company to write software. Everything is waterfall-style locked in with no ongoing support or funding after the production run is done. The software company doesn't care insomuch as it "works" and working to the SCM company is "powers on and functions", not "is secure".
But I do see someone has a HA integration, it just hit the cloud.
> The most fascinating part of this wave of LLM reverse engineering is seeing how many weird and poor choices were lying in plain sight.
I think what's interesting is that for decades one group of devs has been pushing for higher quality and security while other groups have been pushing for "good enough" or "MVP"[0]. Clearly the group that rushed won.But in some weird way we're coming to the day of reckoning. I'm sure we'll always have missed bugs but with a lot of what we're seeing it more seems like these were avoidable problems. Code issues I can easily imagine at least one person on the team said "this isn't acceptable, we need to correct it" and them getting overruled. I'm sure each and every one of you has seen, if not experienced, this.
It'll be interesting to see if that continues. I suspect companies will still rush but from my experience even the best models happily produce shoddy code. And there's a feedback loop, the model's performance is influenced by the code's quality. So it's easy to degrade and get into a bad feedback loop. But I think people still value speed over quality, even in this world where Microsoft shit the bed
[0] in quotes because the entire conversation is essentially about what is actually good enough and what actually is the minimum viable product.
> But there is a good enough in security too.
Of course there is. But you got to at least he good enough to read my footnotes > people will frequently argue that approaches like the one in the article are "good enough" because they don't understand
The same goes for complexity. I've routinely seen people argue against a simpler system by saying "stop making it complex" simply because they don't understand.Its true that complex means multiple things. But there's a strong push against elegance.
I'll give an example. In one job we had to deal with a bunch of different file types. We had a function for each, about 500 lines for each one. Mostly copy pasted. Recognizing that, I wrote one 500 line function that allowed us to write a new file type routine (a common occurrence) in 5 lines. So I removed thousands of lines of code, increased code speed by 10x, decreased developer time by 2x, and by boss (who only ever imported the code, never wrote it) overruled because it was "too complicated" since I was using a C++ abstraction he didn't understand (guy barely knew C++. Like didn't know what a template was).
The problem with both of these is that they slowly lower the bar. If the shortcut was "good enough" last time then another shortcut will be "good enough" this time. If X is "too complex" because I struggle to understand it, then Y is too. Which I find extra ironic since our field is quite egotistical and we seem to revel in the fact that we don't understand. But I guess Dijkstra was writing about that half a century ago. Which is plenty of time for things to go to shit
The good part is that I owned the project and never has been forced to lower a bar I raised back up. Bad code is just stress for no good reason.
This is has been the case since I started developing software in the 90's. As far as I, and likely many others, are concerned it might as well be a Software Aphorism.
I think it will be very interesting as we continue to reverse engineer such things to find out just how poorly "glued together" the Paper Tigers really are....
> This is has been the case since I started developing software in the 90's.
Dijkstra even wrote about it decades before that. But the issue is that this has a feedback loop. It doesn't take long for everything to be made of spaghetti and duct tape. Duct tape is a fine tool, but the real danger is a temporary fix that works is never temporaryI am sure I am one of them. Known unknowns, and unknown unknowns etc.
You might be shit hot at low-level kernel programming but know nothing about networking for example. Or amazing distributed system design and architecture but missing fundamentals about POSIX process handling etc. And so on and so on. I've seen this even in BigCos where hiring bar is high and they try to recruit "generalists". Not everyone can know everything.
Yes, there are trade-offs but that's never how we have those conversations. It's never about weighing the options. We generally have these conversations by dismissing each other's concerns (arguably not a conversation). There's a strong pattern that we dismiss future costs (or future rewards). Why pay $5 now when I could pay $1 is what people hear even if it's "in 10 years you'll make 1000x what you put in" or "in 10 years it'll cost you 1/(10^x) of your net worth". Now matters but we have to remember that so does the future. You can't be penny wise and pound foolish, unless you're a monopoly or extravagantly rich.
"The S in IoT stands for security" has been a joke for 20 years now.
It's always been in plain sight. There's a whole search engine dedicated to it: https://www.shodan.io/ (since 2009)
I highly recommend this talk from 14 years ago: https://youtu.be/5cWck_xcH64?is=O4zCafVz-6eXRYES
Same with I think the lichess android app at the time, except on every sign on.
I used Claude to reverse a widget recently. Turns out that the microcontroller is a perfectly secure chip, unreadable keystore, encrypted firmware, the whole shebang. It would have been nearly impossible to dump.
Except they didn't use the secure key store and did OTA decryption on the fly in 'userspace' as it were. The keys were left in RAM where a debugger can read them and suddenly the device is pwned.
The most fascinating part of this wave of LLM reverse engineering is seeing how many weird and poor choices we’re lying in plain sight.
Any number of people could have discovered and exploited this, but it’s tedious work. Most people who can do this are busy with their job and other things. Now LLMs enable people who understand these things to quickly get through the tedious parts, so they can do a lot more of this work in their free time than they could before.