Why would an adversary being able to execute code as root on a personal computer be a bigger threat than their being able to execute code as non-root? Surely just about any of the stuff that a malicious hacker might want to do to someone's personal computer can be done without root... right?
For one, as non-root user you are tied to the permissions system and can't access most of the data.
If one of your services (let's say sql) get hacked, they are tied to sql user, and unless the achieve privilege escalation, they can't mangle with other services data (eg webserver).
Also network wide, a non-root user can't use different protocol than tcp and udp.
The only reason you can ping as a regular user is because of the setuid on the ping program, otherwise icmp is not allowed to non-root users.
There are of course other reasons, but these are some examples on how it would be different.
I think you're just illustrating my point. Those concerns don't apply to personal computers and they don't stop an intruder from doing anything they might practically want to do for gain. Like installing ransomware, participating in a botnet, exfiltrating personal files/browser cookies/etc (all accessible as non-root!), ...
Apart from rootkit and backdoors that are more difficult to install as non-root, you cannot build specific tunnels as you don't have network permissions.
There are some user space network capabilities, but they are easily breaking, or discovered and in general not resilient to simple reboots.
This is one of the reasons you shouldn't leave your client 24/7 on.
It's true that in personal computers there might not be as much usage of users as in a multiuser computer or a server.
But without root access a virus wouldn't be able to affect system files, so it would have much less persistence and would be much easier for it to be removed, even automatically by some built in or third party antivirus.
Or, it might be possible to just remove it by making a separate user, and accessing the files of the older user from a folder.
In personal cellphones, also, there's heavy sandboxing, so in an OS like android, there would be a big difference betwen root and app compromise, if you don't get root you are only able to access the app data of the app you compromise.
Similar in Mac I think, but I'm not an expert, each app is isolated and a process from one app can only access its own data, escalating to root would allow affecting files of other apps.
But we are talking about containers, so in all likelihood this is about either servers or server developers, which make heavy use of separate users for even single use stuff like an HTTP server, whether manually or automatically, run 'apt/yum install apache2' and you'll see how it creates a separate user automatically.
With a user shell, I can grab their browser data, personal documents, and try to set up persistent background daemons that listen on programs and do keylogging/screenshotting (harder on Wayland than it was on X11).
With root, I can read all program memory, try to extract decryption keys for encrypted filesystems, modify the kernel, punch open backdoors, modify any arbitrary program, read all user files, etc.
A notable extra issue is the rise of AI agents, which often eagerly test the boundaries of every sandbox they are placed within. I would not run an AI agent as root, nor would I give it full access to a rootful container runtime.
The kinds of things that you list that an attacker could do with root access don't sound like things that an actual attacker would want if they are infiltrating random people's personal computers for their own gain. Modifying the kernel or arbitrary programs is so far beyond what typical malware tries to do that I think it seems kind of silly to consider those things when evaluating the security of an operating system designed for personal computers.
To me, they do sound like the kind of things an attacker would want, if they found a reliable, reproducible, automatable path to them. If I was writing malware, ransomware, or just exfiltrating data, I'd be much happier to have root access to do it. Even simple botnets, I'd probably want to try to replace a regular service that most everybody runs (like cupsd) with one that functions exactly like the real one, but also does the malicious activity, and similarly try to patch the package manager to persist it on updates.
The main risk is not that the agent breaks out of their sandbox, although it's an infitesimal possibility (that increases to certainty if you increase the token budget to 100M$ and use subagents to spend it all at once).
The main risk (for you, mere human without a 100M$ budget) is that it downloads a compromised package or vulnerability, or that it runs a stray rm -rf or some stupid stuff. A user provides reasonable protection, you don't NEED a vm (and even then that can be escaped).
Read up on basic user based security. Multiple users can exist on a system, each with its own resources, root/admin can effectively affect any user, so breaking the user-root barrier could allow a user to affect other users.
Originally users meant actual people, but in modern systems users can belong to subsystem, so for example an HTTP server with a website may have its own user, but a mail system could have another, so a breach in the website system would be confined to said user. Going from user to root is called a Local Privilege Escalation and would allow a breach from the website to metastasize into the mail system.
From what I've seen it seems to be a very common opinion that the pro 3 is worse than the pro 1 and 2. Hopefully the new tip design is just a temporary indiscretion like the touch bar.
I think it could be made much faster by emulating Linux system calls instead of running a real kernel, and translating x86 binaries to wasm before running (using something like cheerpx).
Private cloud compute I think. I learnt about it today too from this reddit post which mentions how:
> At WWDC, Apple announced that starting in the 27.x versions of iOS, macOS, etc., devs would be able to call Private Cloud Compute directly from Swift with no additional API configuration. Presently, the only way to get free cloud inference is by joining the App Store Small Business Program.
It's because it's effectively impossible to make a markdown authoring app that meets everyone's needs, and people tend to be picky about what they want in a writing environment. People have strong preferences about WYSIWYG, flavor of markdown (pandoc/quarto/GFM/etc), theming support, some want notes to be able to link to each other, etc. As an example, I require math notation support for basically everything I write which automatically rules out 90% of markdown editors for me.
All of this, but underlying it I've come to the conclusion that Markdown isn't a good format for a writing environment beyond just simple prose. There's too much left up to the flavour of it and it's got weaknesses.
I've been experimenting with using Markdown (in Typora) in place of Word, but it (and others I've looked at) have zero support for image positioning or sizing, or a way to have different (pre-defined) styles on different tables.
Which is a shame because I like keeping my documents in plain text, in version control and efficiently read by my LLMs. LyX (https://www.lyx.org/) for LaTeX is the closest to what I'm thinking of that I know of, but maybe something exists for Asciidoc or Typst.
It probably has more to do with the fact that formalizing chess in such a way wouldn't be particularly interesting. Chess is mostly studied because of its historical significance, and if you change the rules then the game no longer is as connected to its historical significance.
The page already has formalized chess that way. It states that the loser is the first player to have no legal move when their turn occurs. This definition applies to chess with no modification.
But the page also states that chess doesn't meet its definition of a combinatorial game. Why?
I mean... is it not obvious that in a he said she said scenario like this they have to simply side with the buyer? I struggle to understand your mentality, assuming that you have no way to prove (to Amazon or to a court or whatever) that their negative feedback was fraudulent.
The first half of the article says "namespaces, cgroups, and seccomp aren't 'security boundaries' because if the kernel had a bug it could be used to escape from a sandbox". Then in the second half it says "use gvisor and do all this other stuff to avoid these problems." This presentation feels kind of dishonest to me because the article avoids acknowledging the obvious question: "well what if gvisor has a bug then?" I mean, sure, another layer of sandboxing that is simpler than the other layers probably increases security, but let's not pretend like these are fundamentally different approaches.
If the successful people you meet in real life are nice and you see lots of meanness on the internet, it probably just means that anonymity causes meanness.
Or that the internet is full of mean losers. Your premise assumes anyone with an internet connection is successful and I very much doubt that assumption holds water.
Not really - I've seen some pretty mean people back in high school, because high school is one of the places where people are forced to be together, no matter what their preferences are.
But once one becomes an adult, there is a much greater leeway in choosing whom to interact with, so it is often possible to not interact with mean people at all.
Wait. There are people who aren't individually educated by private tutors while they accompany their parents on travel, and at their summer, and winter homes throughout the globe? /s
reply