You you do choose to release it, do it on codeberg because GitHub is Microsoft owned and has an incentive to remove it.

On the first laptop the missing folders are likely to do with the fact that the Flatpaks are installed as system Flatpaks, therefore installed under /var/lib/flatpak (iirc). Flatpak is configured to let you install them as system wide Flatpak apps, meaning other users on your computer will also see them. It would normally require authentication to do that, but many distros configure it to be easy by default.

The second laptop is installing them as user Flatpaks, meaning the folders (mostly shared libraries, desktop entries, and apps) are stored in the user’s home folder.

What does it mean to “make Linux secure”? What does secure mean to you (genuine question). I see people say they can make Linux secure but from what kinds of attacks. I think madaidan’s blog explains why you can’t as an individual fix an issue with the entire ecosystem, or fix the kernel of its inherent security flaws https://madaidans-insecurities.github.io/linux.html

I think “good security” in my personal opinion means that even if you try to run a malicious app, it either crashes out right or can’t do anything because it doesn’t have the permission to.

One thing that I think is very misunderstood is that messy or extremely large/dense code can be very hard to understand, even if you have the source code. Like systemd, it is several million lines of code and is very tangled together. Is it that much better than a blackbox if no one can audit the whole thing (unless you are a massive team)? I do think it is better to have source code and documentation, but vulnerabilities arise from unintended interactions in the code. The more code there is, the higher the chance of this happening.

Just because AOSP uses many of the Linux kernels security features doesn’t magically make other distros more secure. Same with servers vs desktop, which have far different usage requirements and patterns, and vastly different threat models.

Linux desktop is a decade or more behind the curve on exploit mitigations and harm reduction. Social engineering is still a security failure, and it almost as much the fault of OS developers that people are falling for these attacks.

Only recently has sandboxing become more popular for distributing applications, but it still isn’t even close to as secure to AOSP or IOS/MacOS sandboxes. Flatpak and Snap are inherently insecure and that isn’t even their fault because they aren’t really meant to be secure sandboxes; they exist for easy system agnostic app distribution.

Many users still use X11 (or xwayland) which is consistently the source of vulns and regardless is massively insecure. X11 is a nasty rats nest of code and hacks which is massive, complex, and often runs privileged. Ever X11 app has complete access to the X server, and can: record the screen, read all window events and positions, record all keystrokes, send keyboard and mouse events, and much more. Wayland is a good step in the right direction. But Wayland compositors can also suffer from easy attacks, like using LD_PRELOAD to record keystrokes.

Speaking of LD_PRELOAD, most users have .bashrc writeable in there home. Any app that has write access to their home directory can preload a malicious binary which can modify and exploit the running app.

With .bashrc writeable, a hacker can just change tbe user’s $PATH and create a fake sudo binary which records the user’s password, and escalates to root without them knowing. Even specifying the full path isn’t safe, because a hacker can just set an alias which takes priority of the actual path of the binary (eg. /usr/bin/sudo could be an alias of /tmp/sudo).

Now I hear you saying, why didn’t the user just NOT run the malicious script or app? With supply chain attacks being at all time highs, you can’t just rely on trusting your application developer. An app could get compromised and you wouldn’t know. Even if you verify signatures, OpenPGP and GNUPG are inherently broken (see: gpg.fail, Latacora blog, Mathew Green blog)

Most distros use extremely weak memory allocators which allow for easy exploitation of memory corruption vulnerabilities. Hardened_malloc by GrapheneOS works on desktop Linux, with most apps just working fine out of the box. It helps to eliminate (or severely increase the complexity of) memory corruption vulnerabilities.

Many distros don’t use mandatory access control policies like AppArmor or SELinux (eg. Arch Linux and its derivatives), and even if they do it isn’t compare able to AOSP, like Fedora which use SELinux but doesnt by default isolate all applications with strong policies.

Then there are LTS distros, which because of their release schedule and also the way that CVEs are assigned, often miss important patches which go unnoticed (or not triaged for their security impact). See the recent copy.fail vuln which because of its disclosure timeline wasn’t given ahead of time to distros. The only ones affected were slower moving distros, where as rolling release distros were fine (eg Arch Linux).

Of course let’s not forget SETUID and SETGID which are the source of many many privilege escalation attacks, like in the case of that AppArmor vuln about a month ago. Daemon based privilege elevation tools (such as s6-sudo) avoid this problem, but they are not widespread. Systemd’s run0 is a more popular example, but just like everything with systemd it is a massive attack surface and extremely complex under-the-hood.

Linux has many security modules (LSMs) such as MAC (eg. SELinux), Seccomp (for filtering syscalls), Landlock (for filesystem and network isolation), unprivileged user namespaces, etc. The only popular apps which make use of some of these features are browsers.

Of course drivers are another source of vulnerabilities because the are implemented in kernelspace instead of using a standardized ABI.

Linux is not a secure desktop OS. Neither is it very secure for a server OS (without extensive development of tools which properly use the kernels security features).

I could apply most of what I have said to the *BSDs within the context of Desktop OSes.

I agree with most of your points. But the *BSDs are not somehow more secure as a desktop OS. The suffer the same fundamental flaw which are present on Linux: no sane/coherent threat model. Desktop apps run unsandboxed without any MAC policies. The *BSDs also lack many of the useful security features available on Linux (not that most Linux distros do anything with that stuff either, except AOSP and ChromeOS). Just cus a kernel is more “secure” does mean anything when the stuff implemented in userspace doesn’t make use of any of those features.

SELinux is very powerful, same with Seccomp and Landlock. But do any distros make extensive use of that and actually also sandbox applications.

FreeBSD has capsicum (and also an implementation of FLASK?, which is what SELinux is for Linux). OpenBSD has pledge. But are apps required to run in a isolated environment? Many of the *BSDs (and certainly .most of their users) still use X11 instead of modern alternatives like Wayland. The are still monolithic kernels which dont implement drivers in userspace, network, etc in userspace. Not secure at all.

MacOS is more secure, I agree. But it isn’t trying nearly hard enough IMO.

FreeBSD has cleaner code and a far simpler kernel. More eyes on the code doesn’t make the code quality magically better, and vis versa. Linux has many security features not present in the *BSDs, but it also has a massive attack surface and has been historically hostile to security features (see: grsecurity isn’t upstreamed because it was rejected by the kernel maintainers).

Flatpaks are not a secure sandbox. The sandbox exists to distribute apps, and the security is secondary. Apps are very minimally sandboxed. A better permission system would severely weaken the sandbox with basic permissions needed by so many apps. The amount of apps on Flathub that I have seen which need access to org.freedesktop.Flatpak which removes the sandbox. Browsers have their own sandbox crippled because Flatpak blocks namespace access, but that is not a problem for Snaps. Flatpak does not implement many (or any) modern exploit mitigations. Apps that have audio permission have microphone access, and access to all desktop audio. X11 access doesnt use something like Xephyr for a separate X11 to prevent apps from escaping the sandbox, especially on a X11 desktop environment. Etc, etc.

Now dont take me for a Snap shill. I don’t think that is very good either. But at least its permission system is more thorough and apps tend to work better in a lot of cases. It also has on-screen permission requests (at least I think). It still suffers from many of the same problems as Flatpak.

I still use Flatpaks though. Just wish things were better.

In school we had a talk from a guest speaker who professionally developed malware. He said kernel-level anticheat was indistinguishable from malware. He said the same thing about (3rd-party) antivirus.

deleted by creator

It really isn’t that different than regular Fedora Atomic. It offers easy toggles for most security features and some convenient utilities to make things easier.

You can just layer persistent malware (like a .rpm from the internet) using rpm-ostree, or rebase to a malicious image, because rpm-ostree doesnt require a password. Atomic doesnt mean basically anything other than you switch out images, it isnt a security feature. Or have persistent malware by creating a systemd user service that runs on login, or a system service which does the same, and does something malicious (exfiltrate data or keylog [yes that is possible on Wayland with LD_PRELOAD trick]). Or modify the use’rs ~/.bashrc and change the path to include something like /tmp or ~/.local/bin and pit a fake sudo binary which takes president over the real sudo and does something (like steal your user password). Or LD_PRELOAD a malicious binary to everything either by adding a line to the .bashrc, or get root and create /etc/ld.so.preload

The list goes on. It isn’t more secure than regular Fedora. It isn’t a (significant) security feature. It doesn’t protect against persistent malware which resides in the user home, etc, or goes unnoticed as a layered package. rpm-ostree can be used to install anything without needing a password. It isn’t secure.

I was specifically responding to at the end where you say it is “super secure” at the end of your comment. It is not a security focused distro. It isnt even (only) a privacy distro. It is an anonymity distro. Fedora is private, but it doesnt store everything in RAM or route everything through Tor, so it isn’t amnesic or anonymity focused.

When compared to Whonix (which is Debian based like Tails) or Secureblue (Fedora Atomic based), Tails doesnt do nearly anything to harden its base other than to strictly proxy the network through Tor, run in RAM, and some default apps.

Fedora Atomic is not more secure than traditional Fedora. That is a misconception.

Qubes, Kicksecure/Whonix, and Secureblue are basically the only major security focused Linux distros.

Tails is focused on anonymity, not simply privacy (same with Whonix). Tails is not really security hardened.

Tails isn’t really a security focused distro, no significant kernel or other security hardening. It is amnesic. Whonix (based on Kicksecure) is security hardened but still based on Debian which isn’t great for a security base.

Secureblue is what I would recommend because it a security focused Linux distro that benefits from Fedora’s SELinux, and has a bunch of its own additions.

QubesOS is obviously the best for security. Combine that with a Whonix or Secureblue guest OS and you’re perfect.

The eye develop from brain tissue, so I wouldn’t be so sure …

QUIK SMS implements turning “blank liked message” into the proper format, but that still doesnt allow sending emoji reactions.

I was pretty sure that RCS was centralized and requires using the existing infrastructure, which requires some contract with Google or other providers.

Either way, no open source Messenger (that I know of) exists which supports RCS.

That is why I said sending them. You can’t send reactions that people can also see without RCS. QUIK SMS converts received reactions into the proper format but still can’t send them.

Sending them requires the proprietary RCS protocol. Only google messages and a couple others can do it. Infrastructure for RCS is owned by Google, Apple, and some carriers IIRC

QKSMS has been dead for years. QUIK SMS is a revival QKSMS: https://f-droid.org/packages/dev.octoshrimpy.quik.fdroid

Funnily enough OpenRC is probably the slowest of the inits offered by Artix. The current best in both features and stability are Dinit and s6. Dinit is far more user friendly. Both boot ~20% faster than the others, and much faster than systemd. Generally though, simplicity without expense to features is what Dinit and s6+66 excel at.

Gentoo wiki page comparing inits: https://wiki.gentoo.org/wiki/Comparison_of_init_systems

From the Dinit developer: https://github.com/davmac314/dinit/blob/master/doc/COMPARISON