Skip to content

LordOS — a free, fast and secure GNU/Linux distribution based on Debian, with its own desktop environment: display server and Wayland compositor in C, a React UI engine on QuickJS, and private native apps.

Paper and feature pages: 0.8.0 Beta, the first public release

Federico Pereirae754e18297d3
diff --git a/docs/PAPER.md b/docs/PAPER.md
index 7860710..793dcf7 100644
--- a/docs/PAPER.md
+++ b/docs/PAPER.md
@@ -2,7 +2,7 @@
*Technical whitepaper: design, security model and current state*
-Version 0.7.0 Beta · 2026-10-18 · Pablo Miranda, Federico Pereira (IPERFEX)
+Version 0.8.0 Beta · 2026-10-18 · Pablo Miranda, Federico Pereira (IPERFEX)
> This is the English copy of the paper published on lordos.org, where the figures are drawn as
> diagrams. Source: `web/content/paper/paper.en.md` and `web/content/paper/diagrams.json`.
@@ -11,7 +11,7 @@ Version 0.7.0 Beta · 2026-10-18 · Pablo Miranda, Federico Pereira (IPERFEX)
LordOS is a free GNU/Linux distribution based on Debian 13 that ships a desktop environment of its own, built from its fundamental components on top of Debian and Wayland. Instead of GNOME or KDE, it has its own display server and Wayland compositor written in C (`lord-server`), its own user-interface engine (React running on the QuickJS JavaScript engine, with layout, painting and text in native C code), its own native apps, and its own security services: an app sandbox launcher, a permission broker, a per-app permission store, a kernel-enforced per-app firewall, package signing and an encrypted password vault. It reuses what is mature and widely reviewed: the Linux kernel, Debian and its packages, Mesa, PipeWire, the Wayland protocol, and a handful of libraries (FFmpeg, Poppler, libarchive, OpenSSL, Monocypher) that are confined to small sandboxed helper processes.
-This paper describes the design and the current state of version **0.7.0 Beta** (October 2026) for a technical reader who wants to check the project rather than take it on trust. Every claim refers to a file in the public repository. Numbers are the ones measured in the project's test logs, and are labelled with where they were measured. Things that are designed but not built are marked as such.
+This paper describes the design and the current state of version **0.8.0 Beta** (October 2026), the first public release, for a technical reader who wants to check the project rather than take it on trust. Every claim refers to a file in the public repository. Numbers are the ones measured in the project's test logs, and are labelled with where they were measured. Things that are designed but not built are marked as such.
## 1. Vision
@@ -102,7 +102,7 @@ A running LordOS system has a small number of processes with clearly separated r
|---|---|---|
| `lord-sessiond` | root | login screen, sessions, lending the display and input to the visible session, remote desktop |
| `lord-netd` | root | the system network: DHCP, Wi-Fi, VPN; only the `net-*` actions |
-| `lord-netperm` | root (limited capabilities) | per-app network rules, enforced with cgroup eBPF |
+| `lord-netperm` | root (limited capabilities) | per-app network rules, and the device and Bluetooth restrictions of Linux apps, enforced with cgroup and LSM eBPF programs |
| `lord-fand` | root (no capabilities) | fan control by temperature |
| `lord-server` | the user | one per session: compositor, UI engine, broker |
| `lord-server --app <id>` | the user, sandboxed | one per running `.lpk` app (and Passwords) |
@@ -167,7 +167,7 @@ The compositor (`server/src/wl/wl.c`) uses only `libwayland-server` and code gen
Linux windows enter the SDK's window manager like any other, with title, focus, maximize, minimize and a Dock icon. Apps that ask for server-side decoration get the theme's frame; apps that draw their own (GTK 4) keep it, and their shadow is clipped. GTK 4 and libadwaita apps follow light/dark mode, the accent and the button order through an `org.freedesktop.portal.Settings` implementation that `lord-server` serves itself on the session bus; GTK 3 follows through the GSettings keyfile.
-**Xwayland is not supported**: LordOS doesn't run X11-only apps. Also pending: drag and drop, the primary selection, LordOS input methods inside Linux apps (`text-input`), activation (`xdg-activation`), explicit sync and SVG app icons. No screen-capture protocol is offered to apps.
+**Xwayland is not supported yet**: LordOS doesn't run X11-only apps (Xwayland is planned before 1.0, §10.3). Also pending: drag and drop, the primary selection, LordOS input methods inside Linux apps (`text-input`), activation (`xdg-activation`), explicit sync and SVG app icons. No screen-capture protocol is offered to apps.
### 3.5 Several displays and HiDPI
@@ -201,6 +201,7 @@ Every connected display is driven at once, extended or mirrored, in one logical
- **One session per user**, all able to live at once (fast user switching). Each is a `lord-server` that starts as root and drops privileges right away.
- **Display lending.** `lord-sessiond` opens the graphics card and the input devices as root and lends them to the session that is on the monitor, over a Unix socket. On a switch it revokes them: `EVIOCREVOKE` makes the old session's input file descriptors stop working, and `DROP_MASTER` takes display control away, before anything is given to the next session. The visible session keeps composing on the GPU without ever being root. A session off the monitor draws in memory, and only if someone is watching it remotely.
- **Locking really takes the session off the monitor**; it is not a layer drawn on top. If the user's session hangs, the login screen still works.
+- **Boot.** A LordOS GRUB theme draws the boot menu, and a LordOS Plymouth theme draws the splash (the crown with a progress bar). The hand-off has no black frame and no console text: Plymouth stops drawing and gives up display control while its last frame stays on screen, `lord-sessiond` takes display control and sets the first real frame of the login screen, and only then does Plymouth quit, keeping the splash on screen until it is replaced.
**Remote desktop.** The same service offers the desktop to a browser on the local network at `https://<address>:5673` (5673 spells "LORD" on a phone keypad). It is **off by default** and is turned on in Settings → Sharing. It uses TLS 1.2 or later with a self-signed P-256 certificate whose fingerprint Settings shows for comparison, a strict content security policy, same-origin checks, per-IP waits on failed logins, and a session cookie that is `Secure`, `HttpOnly` and `SameSite=Strict`. The login page never lists user accounts. The process that serves a connection drops root as soon as it knows whose session it is. Screen updates are sent as PNG when still and JPEG while moving. Audio is designed but not built. Internet access is not intended; a VPN is recommended.
@@ -210,6 +211,7 @@ Every connected display is driven at once, extended or mirrored, in one logical
- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c), [server/src/tp](https://github.com/lordbasex/LordOS/tree/main/server/src/tp), [server/src/ui/grab.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/grab.c)
- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c), [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c)
- [server/src/remote/sessiond.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sessiond.c), [server/src/remote/monitor.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/monitor.c), [server/src/remote/sess.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sess.c)
+- [tools/boot/plymouth](https://github.com/lordbasex/LordOS/tree/main/tools/boot/plymouth), [tools/iso/grub](https://github.com/lordbasex/LordOS/tree/main/tools/iso/grub), [docs/SESSIONS.md](https://github.com/lordbasex/LordOS/blob/main/docs/SESSIONS.md)
## 4. The UI engine
@@ -287,7 +289,7 @@ The Store shows Debian's apps by category with search, `.lpk` apps and local `.d
### 5.4 Linux apps
-Linux apps with a `.desktop` file appear in the app launcher. Launching goes through `lord.apps.launch(id)`: the interface can only name an installed `.desktop` file; `lord-server` re-reads it, checks it, builds `argv` from its `Exec` line by the specification and runs it with `execve`, without a shell or caller arguments, inside its own root-owned cgroup scope. Chromium and Firefox are preinstalled in the ISO and were verified with the LordOS frame. **Linux apps are not sandboxed by LordOS**; they get attribution and the per-app firewall (§6.6).
+Linux apps with a `.desktop` file appear in the app launcher. Launching goes through `lord.apps.launch(id)`: the interface can only name an installed `.desktop` file; `lord-server` re-reads it, checks it, builds `argv` from its `Exec` line by the specification and runs it with `execve`, without a shell or caller arguments, inside its own root-owned cgroup scope. Chromium and Firefox are preinstalled in the ISO and were verified with the LordOS frame. **Linux apps are not sandboxed by default**: they run as the user, as on any Debian system. They get attribution, the per-app firewall and the per-app restrictions the owner sets (§6.6), including an optional "no access to your files" view applied by the launcher.
### 5.5 WebAssembly
@@ -297,7 +299,7 @@ LordOS includes its own WebAssembly interpreter in C (`server/src/wasm`), expose
- **Live ISO** for 64-bit PCs, with a graphical installer (UEFI and BIOS).
- **Raspberry Pi 5 image** for SD card or NVMe (§7.4).
-- **On an existing Debian 13**: `curl -fsSL https://lordos.org/install.sh | sh`. The script asks before changing anything, downloads `SHA256SUMS` and verifies its Ed25519 signature with the release key embedded in the script, refuses to continue without a valid signature, checks the `.deb`'s SHA-256, installs it with apt and sets the system up like the ISO. The repository is private until the first public beta, so the download path is not public yet.
+- **On an existing Debian 13**: `curl -fsSL https://lordos.org/install.sh | sh`. The script asks before changing anything, downloads `SHA256SUMS` and verifies its Ed25519 signature with the release key embedded in the script, refuses to continue without a valid signature, checks the `.deb`'s SHA-256, installs it with apt and sets the system up like the ISO. The release files are published on GitHub Releases.
### Source files
@@ -318,7 +320,7 @@ LordOS is designed against these threats:
- **An attacker on the local network** trying to use the remote desktop or to tamper with downloads.
- **Tampered packages and releases.**
-Outside the model, for now: a compromised kernel or root account; physical attacks; side channels; and Linux apps reading the user's files (they run as the user, as on any Debian system). Linux apps are confined only on the network.
+Outside the model, for now: a compromised kernel or root account; physical attacks; side channels; and Linux apps that the owner hasn't restricted, which run as the user, as on any Debian system, and can read the user's files. Linux apps are confined only by the restrictions the owner sets for them (§6.6), and only when they are started from the app launcher.
### 6.2 Least privilege
@@ -338,7 +340,18 @@ Outside the model, for now: a compromised kernel or root account; physical attac
| `lord-netperm` | `RELOAD` with no data | run programs; take arguments; open internet sockets |
| `lord-fand` | `STATUS` for anyone; `PROFILE`, `CURVE`, `FORCE` for administrators | name paths or devices; run programs; use the network |
-### 6.4 The app sandbox
+### 6.4 What is isolated, and the app sandbox
+
+Not every program on LordOS is sandboxed. This is exactly what applies to each kind:
+
+| Kind | Process | Sandbox | cgroup scope | Broker and permissions | Firewall and restrictions (§6.6) |
+|---|---|---|---|---|---|
+| `.lpk` apps and Passwords | own (`lord-server --app <id>`) | Landlock, seccomp, no capabilities | own, root-owned, with limits | every call checked in C | network rules and all eight non-network restrictions, in the broker |
+| Other built-in apps | inside `lord-server` | no (they are part of the desktop) | `lord-server`'s | no broker; camera, microphone and screen are checked in C | as "LordOS": network rules; camera, microphone, screen and notifications |
+| Linux apps from the app launcher | own | none by default; with "no access to your files", their own user, mount and PID namespaces plus Landlock, from the next launch | own, root-owned | no | network rules; camera, microphone, USB, Bluetooth sockets, files and notifications; not the clipboard |
+| Terminal programs | children of the Terminal's shell | no | `lord-server`'s | no | as "LordOS": network rules |
+
+A program started some other way, outside the app launcher, is in no app scope and gets no per-app rules. Flatpak and bubblewrap are not used.
Each `.lpk` app, and the Passwords app, runs as `lord-server --app <id>`: the same binary in "app mode", launched by `lord-server` with a validated package id as its only argument. The process connects to the compositor as a Wayland client and opens the broker socket, then applies the sandbox, and only then loads the app's code (`server/src/sec/sandbox.c`):
@@ -384,39 +397,91 @@ The isolated app talks to `lord-server` only over one `SOCK_SEQPACKET` socket. E
- **Revocation:** denying the camera or the microphone in Settings stops it at once (the app's `lord-media` is killed; the PipeWire stream is closed). The `network` permission is decided at launch.
- **Keyring:** an isolated app's keyring requests carry an owner that `lord-server` sets from the verified app id.
-**Limits.** There is no "allow once". Some declared permissions (Bluetooth, launching apps, notifications) have no broker call yet, so isolated apps can't use those capabilities at all; listening on a port is governed by the network permission. A Linux app running as the user could edit the permissions file.
+**Restrictions beat permissions.** A firewall restriction (§6.6) wins over any stored decision: the request is refused without a prompt, even if the app was allowed before, and restricting a running app takes its camera and microphone away at once, like revoking.
-### 6.6 The per-app firewall and the Monitor
+**Limits.** There is no "allow once". Some declared permissions (Bluetooth, launching apps, notifications) have no broker call yet, so isolated apps can't use those capabilities at all; listening on a port is governed by the network permission. A Linux app running as the user could edit the permissions file, unless it is restricted with "no access to your files".
-**Figure: The path of a connection.**
+### 6.6 The per-app firewall, its restrictions and the Monitor
+
+**Figure: The path of a connection or a device.**
```
-[App opens a connection] connect, sendto, bind or socket
+[App opens a connection or a device] connect, sendto, bind, socket, or open() of a device node
│ system call
▼
-[cgroup eBPF hook] In the kernel; finds the app by its scope
+[eBPF programs in the kernel] cgroup network hooks; cgroup/dev for camera, USB, ALSA capture and /dev/fb; BPF LSM socket_create for Bluetooth. The app is found by its scope
│ map lookup
▼
-[Per-app rules] Restrictions, then the most specific rule, then trusted, then mode
+[Per-app rules] Restrictions first, then the most specific rule, then trusted, then mode
│ decision
▼
[Allow or deny] Denied: the app gets EPERM
│ ring buffer
▼
-[Monitor map] New connections and counters, once per second
+[Monitor map] New connections, denials and counters, once per second
```
-*The decision happens in the kernel when the connection opens; nothing runs per packet.*
+*The decision happens in the kernel when a connection, a socket or a device opens; nothing runs per packet.*
-`lord-netperm` enforces per-app network rules in the kernel. Linux apps opened from the app launcher run in `app-lordos-<id>.scope`, `.lpk` apps in `app-lordos-lpk-<id>.scope`, and the rest of the session counts as `lordos`. All scopes are root-owned. The service loads seven cgroup eBPF programs (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`) into the cgroup of `lordos.service`, finds each process's app by its cgroup ancestor, and returns allow or deny (`EPERM`). The programs are compiled into the binary and loaded with LordOS's own loader over the `bpf()` system call; libbpf and bcc are not used.
+`lord-netperm` enforces per-app rules in the kernel. Linux apps opened from the app launcher run in `app-lordos-<id>.scope`, `.lpk` apps in `app-lordos-lpk-<id>.scope`, and the rest of the session counts as `lordos`. All scopes are root-owned. The service loads seven network programs (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`), a device program (`cgroup/dev`) and a per-cgroup LSM program on `socket_create` into the cgroup of `lordos.service`, finds each process's app by its cgroup ancestor, and returns allow or deny (`EPERM`). The programs are compiled into the binary and loaded with LordOS's own loader over the `bpf()` system call, which also reads the kernel's BTF to find the LSM hook; libbpf and bcc are not used. If the kernel refuses the device or the LSM program, the network programs still work and the service says so.
- **Rules** support exact domains, wildcards, IPv4/IPv6 networks, `lan`, `internet`, ports, protocols and direction. Restrictions (no internet, no LAN, no network, no incoming) come first; then the most specific rule wins, with deny beating allow at equal specificity; then trusted apps; then the mode (silent, the default, or off). `npcompile.c` precomputes this into hash and longest-prefix-match maps. A test runs the kernel's decision code against the reference decision maker over 480,000 random connections: 0 differences.
-- **Domain names** come only from the system resolver: systemd-resolved's monitor interface or, without it, replies from port 53 of the configured servers read by a receive-only packet socket. Answers an app received on its own sockets are never trusted.
+- **Domain names** come only from the system resolver: systemd-resolved's monitor interface or, without it, replies from port 53 of the configured servers read by a receive-only packet socket. Answers an app received on its own sockets are never trusted. So an app that resolves names itself with encrypted DNS (DNS over HTTPS inside a browser, for example) isn't matched by domain rules: an "allow only example.com" rule still blocks it, but a "block example.com" rule doesn't stop it. Address and network rules, the app's default and its restrictions still apply, and Settings says so under the rules.
+- **Rules in the interface.** Settings → Privacy → Network rules by app shows each app's default ("allow all" or "block all except rules") and its rules in the order they win, with when each one last matched; the sheet that adds a rule checks what is typed as it is typed. In Monitor → Network, "Allow / Block this domain" on one of an app's destinations opens the same sheet, prefilled with the name the system resolver gave for that address.
- **Escapes.** The cgroup tree is root-owned, so an app can't move itself. A process that asks the user's systemd manager for a new unit (`systemd-run --user`) lands under `user@<uid>.service`; `lord-netperm` attaches the same programs there and holds such processes to the strictest union of that user's running restricted apps. Tested: all escape attempts denied, other users unaffected.
- **Cost**: about 0.5 µs per UDP connect, TCP within noise, no change in throughput, since nothing runs per packet.
-- **The Monitor** shows each app's connections (from `sock_diag`), bytes, destinations by country from a local database, and a per-app Rule switch. No address ever leaves the machine for lookups: no reverse DNS, no online geolocation.
+- **The Monitor** shows each app's connections (from `sock_diag`) and the destinations the firewall reported recently, bytes, destinations by country from a local database, and a per-app Rule switch. No address ever leaves the machine for lookups: no reverse DNS, no online geolocation.
+
+**Restrictions beyond the network.** Besides the four network restrictions (no internet, no LAN, no network, no incoming connections), the owner can restrict an app from the camera, the microphone, the screen, USB, files, the clipboard, Bluetooth and notifications. Each one is enforced where the resource is handed out, checked against the app's scope and never against a name the app gives itself, and it beats any permission granted in `permisos.json`.
+
+**Figure: Where each restriction is enforced.**
-**Limits.** "Ask" mode is designed but behaves as silent today. There is no interface yet for domain rules or per-destination switches (the engine and the API support them). ICMP is blocked only by "no network"; connections to an already-open port aren't checked. Settings also offers non-network restrictions (camera, microphone, screen, USB, Bluetooth, files, notifications): they are stored, but **no component enforces them yet**.
+```
+Broker in lord-server
+ .lpk apps and Passwords: all eight restrictions, refused without a prompt
+ │
+App launcher
+ Linux apps, no access to your files: own user, mount and PID namespaces, a tmpfs home and Landlock, from the next launch
+ │
+Notification server (notifyd)
+ Linux apps' notifications: the sender's identity comes from the bus; failures drop it
+ │
+PipeWire guard (pwguard)
+ Microphone and camera through PipeWire: identity from the socket's credentials, applied live
+ │
+lord-netperm's eBPF programs in the kernel
+ Network hooks; cgroup/dev for camera, USB, ALSA capture and /dev/fb; BPF LSM socket_create for Bluetooth sockets
+```
+
+*Each restriction is checked where the resource is handed out, against the app's root-owned scope, never against a name the app gives itself.*
+
+| Restriction | `.lpk` apps and Passwords | Built-in apps ("LordOS") | Linux apps from the app launcher |
+|---|---|---|---|
+| camera | broker (`brokercam.c`) | `js_media.c` | `cgroup/dev` on V4L2 nodes, and the PipeWire guard |
+| microphone | broker | `js_media.c` | the PipeWire guard, and `cgroup/dev` on ALSA capture nodes |
+| screen | broker (no capture API in app mode) | `js_media.c` | by design: no capture protocol, no X server, no screen-cast portal; `/dev/fb*` denied |
+| USB | broker (the security key of Passwords) | not offered | `cgroup/dev`: raw USB, hidraw and USB serial nodes |
+| files | broker (file picker, camera saves) | not offered | the launcher: own namespaces, a tmpfs home and Landlock, from the next launch |
+| clipboard | broker | not offered | not available |
+| Bluetooth | broker (no Bluetooth API in app mode) | not offered | BPF LSM program on `socket_create`: no `AF_BLUETOOTH` sockets |
+| notifications | the `notifications` permission | `sdk/notify.js` | `notifyd`, by the caller's verified identity |
+
+For isolated apps the broker (`sec/restrict.c`) is the single enforcement point: a restricted request is refused without a prompt, and restricting a running app takes its camera and microphone away at once (`tests/broker_restrict_test.c` covers every restriction, with and without it). The "LordOS" row is the desktop itself (Files, copy and paste, Disks, Bluetooth settings), so it doesn't offer files, USB, clipboard or Bluetooth; individual apps are restricted instead. For Linux apps:
+
+- **Devices.** In cgroup v2 the device controller is a BPF program. `lord-netperm`'s refuses `open()` and `mknod()` of the device classes the app is restricted from (V4L2, raw USB, hidraw, USB serial, ALSA capture nodes, `/dev/fb*`) and allows everything else. It applies to the next `open`; a descriptor already open stays usable.
+- **Bluetooth sockets.** The inet socket hook never sees `AF_BLUETOOTH`, so a per-cgroup LSM program on `socket_create` refuses them.
+- **Files.** Right before `execve`, the launcher's child enters its own unprivileged user, mount and PID namespaces. The home folder is an empty tmpfs holding only the app's own folders (derived from its desktop id, never from fields a `.desktop` file controls) and the file it was opened with; the runtime folder holds only the Wayland and sound sockets, so the session bus and the user's systemd are out of reach; then Landlock limits the rest. It applies at the next launch. GTK apps, Firefox and Chromium run without their D-Bus integrations.
+- **Notifications.** `notifyd` asks the bus for the caller's PID (only an answer the bus itself sent counts), finds its app scope, and drops the notification of a restricted app; an error or a late answer drops it too (fail closed).
+- **Microphone and camera through PipeWire.** The PipeWire guard (`sec/pwguard.c`), `lord-server`'s own PipeWire client, identifies each client by the PID PipeWire took from the socket's credentials and, for a restricted app, hides capture nodes and destroys its capture streams within a second, a recording already running included. While a restricted app runs, a client whose identity can't be established is treated as restricted.
+
+**Limits.** "Ask" mode is designed but behaves as silent today. ICMP is blocked only by "no network"; connections to an already-open port aren't checked. The restrictions for Linux apps don't cover:
+
+- BlueZ over D-Bus: a Bluetooth-restricted app can still ask `bluetoothd` on the system bus to scan, pair and connect;
+- the system bus, which stays reachable even with "no access to your files";
+- the clipboard;
+- apps started outside the app launcher, which are in no app scope;
+- side effects of the `user@` union: while a restricted app runs, the user's own services are held to the same union (a headset's call audio, which PipeWire opens per call, stops for that time);
+- a window of a few milliseconds in which a new PipeWire client of a restricted app has full permissions, or in which a capture stream can receive audio before it is destroyed.
### 6.7 Helpers that process untrusted data
@@ -449,7 +514,7 @@ The isolated app talks to `lord-server` only over one `SOCK_SEQPACKET` socket. E
`.lpk` packages carry a manifest of every file's SHA-256 and an Ed25519 signature over it. SHA-256 and Ed25519 are LordOS's own code (Ed25519 following TweetNaCl's arithmetic), tested against NIST and RFC 8032 vectors (55 of 55). Verification happens in C at install and at load. The Store shows the trust level: **LordOS** (official key, compiled into the binary so no file can add one), **Verified author** (listed in the signed catalog), **Signed by <name>**, or **Unsigned** with a warning. Updates must be signed with the same key. A signed catalog carries a revocation list. If you edit an installed app, LordOS marks it "Modified by you", can restore the original, or can share your version signed with your own key, with credit to the original.
-**Status:** official packages are signed today with a development key; the final key replaces it for the public release. A signed LordOS app repository for the Store is not built yet.
+**Status:** in 0.8.0 Beta, official packages are still signed with a development key, until the final key replaces it. A signed LordOS app repository for the Store is not built yet.
### 6.9 Release signing
@@ -457,7 +522,7 @@ Every release file (the `.deb`, the ISO and the Raspberry Pi image) is listed wi
`c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
-The private key lives only on the maintainer's machine, never in the repository or on a build machine. §11 shows how to check a download.
+The private key lives only on the maintainer's machine, never in the repository or on a build machine. Each release also carries an SPDX 2.3 software bill of materials (SBOM) per architecture, listed in `SHA256SUMS` and so covered by the signature, and its release notes come from `CHANGELOG.md`, kept in the Keep a Changelog format. §11 shows how to check a download.
### 6.10 The vault
@@ -467,13 +532,19 @@ The private key lives only on the maintainer's machine, never in the repository
A window marked protected (Passwords is) is painted black in every path that copies pixels out: screenshots, recordings, thumbnails, the remote desktop, and Wayland menus and fullscreen. The real monitor shows it normally. Linux apps have no screen-capture protocol to begin with.
+### 6.12 Disclosure and standards
+
+Vulnerabilities are reported as described in `SECURITY.md`, which is also published as `/.well-known/security.txt` (RFC 9116). LordOS's processes are **aligned with, not certified against**, ISO/IEC 29147 and ISO/IEC 30111 (vulnerability disclosure and handling), ISO/IEC 5230 (OpenChain license compliance: the inventory in `THIRD_PARTY.md`, the license notices and the SBOM) and ISO/IEC 18974 (OpenChain security assurance: the SBOM plus Debian's security updates for the packages LordOS depends on). lordos.org publishes the legal and trust pages (security policy, code signing, licenses, privacy, support lifecycle, standards) and says what is still missing: no formal self-certification, no automated matching of the SBOM against vulnerability databases, no SBOM for the whole images, and no third-party audit.
+
### Source files
- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c), [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c), [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c), [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c)
- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c), [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c), [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c)
-- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh)
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c), [server/src/sec/pwguard.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/pwguard.c), [server/src/hw/notifyd.c](https://github.com/lordbasex/LordOS/blob/main/server/src/hw/notifyd.c), [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c), [server/tests/broker_restrict_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/broker_restrict_test.c)
+- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh), [tools/release/make-sbom.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/make-sbom.sh)
- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c), [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c)
- [server/src/media/capture.c](https://github.com/lordbasex/LordOS/blob/main/server/src/media/capture.c)
+- [SECURITY.md](https://github.com/lordbasex/LordOS/blob/main/SECURITY.md), [docs/COMPLIANCE.md](https://github.com/lordbasex/LordOS/blob/main/docs/COMPLIANCE.md), [CHANGELOG.md](https://github.com/lordbasex/LordOS/blob/main/CHANGELOG.md)
## 7. Performance
@@ -533,7 +604,7 @@ There are no measurements on real PCs in the repository yet. The ISO is tested o
## 8. Visual experience
- **A design guide.** Apps follow a shared guide (`docs/DESIGN.md`): an 8 px spacing grid, a small type scale, consistent control heights and one accent-coloured action per view. The tokens are exported by the SDK (`spacing`, `typeScale`, `controlSize`), and every app went through documented before-and-after polish passes in light, dark, right-to-left and small windows.
-- **Themes.** A theme is a complete desktop written in React: menu bar, Dock, app launcher, Control Center and window frame, plus its tokens. LordOS ships a default theme with a menu bar and a Dock, and a Classic theme with a taskbar and a start menu. Themes switch live; settings persist.
+- **Themes.** A theme is a complete desktop written in React: menu bar, Dock, app launcher, Control Center and window frame, plus its tokens. LordOS ships a default theme with a menu bar and a Dock, and a Classic theme with a taskbar and a start menu, which today is a template and becomes a second full appearance before 1.0 (§10.3). Themes switch live; settings persist.
- **Light and dark, accents.** Both modes and the accent colour apply live to native apps, isolated apps and, through the portal and GSettings, GTK apps.
- **Right to left.** The whole interface mirrors for Arabic, Hebrew and similar scripts, including isolated apps, which follow the session's language live.
- **Lumo.** LordOS's mascot is Lumo, a small celestial fox, used in welcome screens, empty states and brand material, with a fixed set of poses defined in the brand guide.
@@ -561,14 +632,16 @@ There are no measurements on real PCs in the repository yet. The ISO is tested o
### 10.1 Where things stand
-Milestones M1 to M9 are complete in 0.7.0 Beta: the display server, the UI engine, the SDK and themes, the terminal, languages and complex scripts, Linux app compatibility, packages and system services, sessions, isolation and the firewall, and the M9 app suites (documents and printing, media, system apps, passwords, hardware settings, mail and calendar). The final ISO was built and tested on virtual machines on 18 October 2026.
+0.8.0 Beta is the first public release; 0.7.0 was an internal build and was never published. Milestones M1 to M9 are complete: the display server, the UI engine, the SDK and themes, the terminal, languages and complex scripts, Linux app compatibility, packages and system services, sessions, isolation and the firewall, and the M9 app suites (documents and printing, media, system apps, passwords, hardware settings, mail and calendar). Before the release, the firewall's non-network restrictions became enforced for every kind of app, domain rules got an interface in Settings and the Monitor, the boot got a LordOS splash and GRUB theme, and releases gained a signed SBOM and a changelog. The final ISO was built and tested on virtual machines on 18 October 2026.
### 10.2 Known limitations
- Real hardware: AMD and Nvidia GPUs, real monitors, laptops (battery, backlight, lid), Bluetooth controllers, printers and scanners, FIDO2 keys and real mail providers are untested.
-- The Raspberry Pi 5 hasn't been tested with a monitor, and its built image hasn't been booted yet.
-- Linux apps are not sandboxed; no Xwayland.
-- Firewall: no ask mode, no domain-rule interface, non-network restrictions not enforced.
+- The Raspberry Pi 5 is the only supported board, with LordOS's build of its kernel with Landlock; it hasn't been tested with a monitor, and its built image hasn't been booted yet.
+- Linux apps are not sandboxed by default; no Xwayland yet.
+- Firewall: no ask mode; domain rules don't see apps that resolve names with their own encrypted DNS.
+- Restrictions for Linux apps don't cover BlueZ over D-Bus, the system bus, the clipboard or apps started outside the app launcher; the `user@` union also holds the user's own services while a restricted app runs; a new PipeWire client has a window of a few milliseconds before the guard restricts it (§6.6).
+- The `.lpk` signing key is still a development key, and there is no signed LordOS app repository yet.
- Permissions: no "allow once"; camera and microphone use by Linux apps isn't shown.
- Secure Boot must be turned off; signing with a shim is pending.
- Package downloads use HTTP (signed and hashed).
@@ -577,7 +650,12 @@ Milestones M1 to M9 are complete in 0.7.0 Beta: the display server, the UI engin
### 10.3 Next
-Before the final release: the final ISO with everything and a Raspberry Pi 5 image tested on the real board. After it, as planned in `docs/ROADMAP.md`: a desktop virtualization app built on KVM and QEMU; an Android container with LineageOS and apps from LordOS's Store; the firewall's ask mode; accessibility; and a full demo video.
+Next, a Raspberry Pi 5 image booted and tested on the real board. Before 1.0, as planned in `docs/ROADMAP.md`:
+
+- **Xwayland**, started on demand, with the compositor as the X window manager and X11 apps getting the same per-app identity, firewall and restrictions as Wayland apps;
+- **the Classic theme as a second full appearance**: taskbar, start menu with search, tray, quick settings, notification panel and window snapping, with the same apps in a different skin, built only from LordOS's own design and assets.
+
+After 1.0: a desktop virtualization app built on KVM and QEMU; an Android container with LineageOS and apps from LordOS's Store; the firewall's ask mode; accessibility; and a full demo video.
### Source files
@@ -623,16 +701,18 @@ openssl pkeyutl -verify -pubin -inkey lordos-release.pub.pem -rawin -in SHA256SU
sha256sum -c --ignore-missing SHA256SUMS
```
+The SBOM of each architecture (`lordos_<version>_<arch>.spdx.json`) is listed in `SHA256SUMS` too, so the same check covers it.
+
### 11.4 Check a running system
-- `systemctl status lord-netperm lord-fand lordos` shows the services; the ISO test confirmed seven BPF programs attached.
+- `systemctl status lord-netperm lord-fand lordos` shows the services; the ISO test confirmed the seven network programs attached. If the kernel refuses the device or the LSM program, `lord-netperm` reports `"devices":false` or `"bluetooth":false`.
- `cat /proc/<pid>/status | grep -E 'Seccomp|NoNewPrivs'` on a `lord-server --app` process shows the sandbox.
- `systemd-cgls` shows the root-owned `lordos-session-<uid>` tree with one scope per app.
- Remote desktop: `ss -ltn` shows nothing on port 5673 until you enable it in Settings → Sharing.
## 12. License and credits
-LordOS's code is released under the **MIT license**. Third-party components keep their own licenses, listed in `THIRD_PARTY.md`: QuickJS and stb (vendored), Monocypher (CC0/BSD-2), the EFF word list (CC BY 3.0 US), the common-password list (MIT), DB-IP Lite country data (CC BY 4.0), Natural Earth (public domain), and the Inter, JetBrains Mono and Plus Jakarta Sans fonts (OFL).
+LordOS's code is released under the **MIT license**. Third-party components keep their own licenses, listed in `THIRD_PARTY.md`: QuickJS and stb (vendored), Monocypher (CC0/BSD-2), the EFF word list (CC BY 3.0 US), the common-password list (MIT), DB-IP Lite country data (CC BY 4.0), Natural Earth (public domain), and the Inter, JetBrains Mono and Plus Jakarta Sans fonts (OFL). Each release carries an SPDX SBOM of what the package bundles and depends on (`docs/COMPLIANCE.md`).
LordOS is created by the **IPERFEX** group: **Pablo Miranda** and **Federico Pereira**.
@@ -642,14 +722,18 @@ LordOS is created by the **IPERFEX** group: **Pablo Miranda** and **Federico Per
- **cgroup (v2):** a kernel mechanism that groups processes to account for and limit resources. LordOS gives each app its own group, a "scope", and uses it to identify the app in the firewall.
- **Compositor:** the program that combines the windows of all apps into the final image on screen.
- **DRM/KMS:** the kernel interfaces for graphics devices and for setting display modes.
-- **eBPF:** small verified programs that run inside the kernel; LordOS attaches them to cgroups to decide network connections.
+- **eBPF:** small verified programs that run inside the kernel; LordOS attaches them to cgroups to decide network connections, device opens and Bluetooth sockets.
- **evdev:** the kernel interface for input devices.
+- **LSM (BPF LSM):** the kernel's security hooks; with the `bpf` LSM, a small program attached per cgroup can refuse an operation, such as creating a Bluetooth socket.
+- **Namespace:** a kernel feature that gives a process its own view of something (users, mounts, process ids); LordOS uses unprivileged ones for Linux apps restricted from the user's files.
- **Helper:** a small LordOS process that handles untrusted data or secrets in a stricter sandbox (`lord-doc`, `lord-media`, `lord-maild`, `lord-vault`).
- **Landlock:** a kernel feature that lets an unprivileged process restrict which files and network ports it, and its children, may use.
- **`.lpk`:** LordOS's package format for installable native apps.
- **`.lvault`:** LordOS's encrypted vault file format.
+- **PipeWire guard:** `lord-server`'s own PipeWire client that hides capture devices from restricted Linux apps and stops their capture streams.
- **Powerbox:** a file dialog drawn by the system that hands the app only the file the user chose.
- **QuickJS:** a small JavaScript engine written in C.
+- **SBOM:** a software bill of materials, the machine-readable list of the components a release contains, in the SPDX format.
- **Scope:** a cgroup for one app, such as `app-lordos-lpk-<id>.scope`.
- **seccomp-bpf:** a kernel filter that restricts which system calls a process may make.
- **Secret Service:** the freedesktop D-Bus standard Linux apps use to store secrets.
@@ -664,8 +748,8 @@ LordOS is created by the **IPERFEX** group: **Pablo Miranda** and **Federico Per
| 3. Compositor | GPU.md, DISPLAYS.md, WINDOWS.md, TRACKPAD.md, WAYLAND.md, SESSIONS.md, REMOTE.md |
| 4. UI engine | ARCHITECTURE.md, LANGUAGES.md, TERMINAL.md |
| 5. Applications | NATIVE-APPS.md, PACKAGES.md, WASM.md, FILES.md, MEDIA.md, DOCUMENTS.md, MAIL.md, ISO.md, INSTALL-DEBIAN.md |
-| 6. Security | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md |
+| 6. Security | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md, COMPLIANCE.md, and `SECURITY.md` |
| 7. Performance | ISO.md, RASPBERRY.md, FANS.md, DISPLAYS.md, GPU.md |
| 8. Visual experience | DESIGN.md, LORDOS-BRAND.md, LANGUAGES.md, DOCK.md |
| 9. Extensibility | NATIVE-APPS.md, WASM.md, and `apps/README.md`, `themes/README.md` |
-| 10. Roadmap | ROADMAP.md and `CHANGELOG.md` |
+| 10. Roadmap | ROADMAP.md, RELEASING.md and `CHANGELOG.md` |
diff --git a/web/content/features/linux-apps.en.md b/web/content/features/linux-apps.en.md
index 63cfde8..be6ee3f 100644
--- a/web/content/features/linux-apps.en.md
+++ b/web/content/features/linux-apps.en.md
@@ -22,7 +22,7 @@ Apps with a `.desktop` file appear in the app launcher, the Classic theme's star
1. The interface can only pass the **id** of a `.desktop` file that is already installed in `/usr/share/applications` or `~/.local/share/applications`, never a command.
2. `lord-server` re-reads that file, checks it is a real, visible, non-terminal application, and builds the command from its `Exec` line by the specification, without a shell and without arguments from the caller. "Open With" in Files may add exactly one file, only if the app declares the file types it handles and the file is in your home folder or on a disk you mounted.
-3. The app is started in its own cgroup, `app-lordos-<id>.scope`, created by root, so the Monitor and the per-app firewall know which app each process belongs to.
+3. The app is started in its own cgroup, `app-lordos-<id>.scope`, created by root, so the Monitor, the per-app firewall and its restrictions know which app each process belongs to. If you restricted the app from your files, this is also where it gets its own view: its own namespaces, an empty home folder with only its own folders, and Landlock.
JavaScript in LordOS can't write `.desktop` files, so the interface can't invent a command: it can only pick an app that is already installed.
@@ -51,11 +51,11 @@ Deliberately absent: any protocol that lets an app capture the screen or other a
## The skeptical reader's questions
-**Are Linux apps sandboxed?** No. This is important: they run as your user, as on any Debian system, and can read your home folder. What LordOS adds is a per-app cgroup, attribution in the Monitor, and the kernel-enforced per-app firewall (allow, deny, LAN only, no incoming connections). Only LordOS's own `.lpk` apps get the full sandbox.
+**Are Linux apps sandboxed?** Not by default. This is important: they run as your user, as on any Debian system, and can read your home folder. What LordOS adds is a per-app cgroup, attribution in the Monitor, the kernel-enforced per-app firewall (allow, deny, LAN only, no incoming connections, rules by domain or address), and restrictions you can set per app: no camera, no USB and no Bluetooth sockets (in the kernel), no microphone (LordOS's PipeWire guard plus the sound card's capture nodes), no notifications, and "no access to your files", applied from the next launch. They don't cover the clipboard, Bluetooth through BlueZ on the system bus, or programs started outside the app launcher. Only LordOS's own `.lpk` apps get the full sandbox.
-**Can a Linux app see other windows or record the screen?** Not through LordOS. The compositor only gives an app its own surfaces and offers no screen-capture protocol, so protected windows like Passwords stay private from them too.
+**Can a Linux app see other windows or record the screen?** Not through LordOS. The compositor only gives an app its own surfaces and offers no screen-capture protocol, there is no X server and no screen-cast portal, and a restricted app is also denied the framebuffer device, so protected windows like Passwords stay private from them too.
-**What about X11-only apps?** They don't run: Xwayland is not part of LordOS. Current GTK and Qt apps speak Wayland, and so did the SDL game tested.
+**What about X11-only apps?** They don't run yet: Xwayland is not part of LordOS 0.8.0 Beta. It is planned before 1.0, with X11 apps getting the same per-app identity, firewall and restrictions. Current GTK and Qt apps speak Wayland, and so did the SDL game tested.
**And Flatpak?** LordOS doesn't use or integrate it, and it hasn't been tested.
@@ -63,7 +63,7 @@ Deliberately absent: any protocol that lets an app capture the screen or other a
## Honest limits
-- **No Xwayland,** so no X11-only apps.
+- **No Xwayland yet** (planned before 1.0), so no X11-only apps.
- **Not yet:** drag and drop between apps, the middle-click primary selection, LordOS input methods (Korean, Japanese, Chinese) inside Linux apps, and app activation requests.
- **SVG-only icons:** LordOS doesn't draw SVG yet. It uses the PNG icons Debian publishes for most apps, or the initial.
- **Terminal apps** with a `.desktop` file aren't shown in the app launcher; start them from the Terminal.
diff --git a/web/content/features/linux-apps.es.md b/web/content/features/linux-apps.es.md
index 2cb9c7d..b3a09f5 100644
--- a/web/content/features/linux-apps.es.md
+++ b/web/content/features/linux-apps.es.md
@@ -22,7 +22,7 @@ Las apps con un archivo `.desktop` aparecen en el lanzador de apps, en el menú
1. La interfaz solo puede pasar el **id** de un archivo `.desktop` que ya esté instalado en `/usr/share/applications` o `~/.local/share/applications`, nunca un comando.
2. `lord-server` vuelve a leer ese archivo, verifica que sea una aplicación real, visible y que no sea de terminal, y arma el comando a partir de su línea `Exec` según la especificación, sin shell y sin argumentos de quien llama. "Abrir con" en Archivos puede agregar exactamente un archivo, solo si la app declara los tipos de archivo que maneja y el archivo está en tu carpeta personal o en un disco que montaste.
-3. La app arranca en su propio cgroup, `app-lordos-<id>.scope`, creado por root, así el Monitor y el firewall por app saben a qué app pertenece cada proceso.
+3. La app arranca en su propio cgroup, `app-lordos-<id>.scope`, creado por root, así el Monitor, el firewall por app y sus restricciones saben a qué app pertenece cada proceso. Si le restringiste a la app tus archivos, acá es también donde recibe su propia vista: sus propios espacios de nombres, una carpeta personal vacía con solo sus propias carpetas, y Landlock.
El JavaScript de LordOS no puede escribir archivos `.desktop`, así que la interfaz no puede inventar un comando: solo puede elegir una app que ya está instalada.
@@ -51,11 +51,11 @@ Ausente a propósito: cualquier protocolo que le permita a una app capturar la p
## Las preguntas del lector escéptico
-**¿Las apps de Linux están en una caja de arena?** No. Esto es importante: corren como tu usuario, como en cualquier sistema Debian, y pueden leer tu carpeta personal. Lo que LordOS suma es un cgroup por app, la atribución en el Monitor y el firewall por app que aplica el kernel (permitir, denegar, solo LAN, sin conexiones entrantes). Solo las apps `.lpk` propias de LordOS tienen la caja de arena completa.
+**¿Las apps de Linux están en una caja de arena?** No de forma predeterminada. Esto es importante: corren como tu usuario, como en cualquier sistema Debian, y pueden leer tu carpeta personal. Lo que LordOS suma es un cgroup por app, la atribución en el Monitor, el firewall por app que aplica el kernel (permitir, denegar, solo LAN, sin conexiones entrantes, reglas por dominio o dirección) y restricciones que podés fijar por app: sin cámara, sin USB y sin sockets Bluetooth (en el kernel), sin micrófono (la guardia de PipeWire de LordOS más los nodos de captura de la placa de sonido), sin notificaciones y "sin acceso a tus archivos", que se aplica desde el próximo inicio. No cubren el portapapeles, el Bluetooth a través de BlueZ en el bus del sistema ni los programas iniciados fuera del lanzador de apps. Solo las apps `.lpk` propias de LordOS tienen la caja de arena completa.
-**¿Una app de Linux puede ver otras ventanas o grabar la pantalla?** No a través de LordOS. El compositor solo le da a una app sus propias superficies y no ofrece ningún protocolo de captura de pantalla, así que las ventanas protegidas como Contraseñas también quedan a salvo de ellas.
+**¿Una app de Linux puede ver otras ventanas o grabar la pantalla?** No a través de LordOS. El compositor solo le da a una app sus propias superficies y no ofrece ningún protocolo de captura de pantalla, no hay servidor X ni portal de captura de pantalla, y a una app restringida también se le niega el dispositivo de framebuffer, así que las ventanas protegidas como Contraseñas también quedan a salvo de ellas.
-**¿Y las apps que solo usan X11?** No funcionan: Xwayland no es parte de LordOS. Las apps GTK y Qt actuales hablan Wayland, y también el juego SDL que se probó.
+**¿Y las apps que solo usan X11?** Todavía no funcionan: Xwayland no es parte de LordOS 0.8.0 Beta. Está planeado antes de la 1.0, con las apps X11 con la misma identidad por app, el mismo firewall y las mismas restricciones. Las apps GTK y Qt actuales hablan Wayland, y también el juego SDL que se probó.
**¿Y Flatpak?** LordOS no lo usa ni lo integra, y no se probó.
@@ -63,7 +63,7 @@ Ausente a propósito: cualquier protocolo que le permita a una app capturar la p
## Límites honestos
-- **Sin Xwayland,** así que no hay apps que usen solo X11.
+- **Todavía sin Xwayland** (planeado antes de la 1.0), así que no hay apps que usen solo X11.
- **Todavía no:** arrastrar y soltar entre apps, la selección primaria con clic del medio, los métodos de entrada de LordOS (coreano, japonés, chino) dentro de las apps de Linux, y los pedidos de activación de apps.
- **Íconos solo en SVG:** LordOS todavía no dibuja SVG. Usa los íconos PNG que publica Debian para la mayoría de las apps, o la inicial.
- **Las apps de terminal** con archivo `.desktop` no aparecen en el lanzador de apps; arrancalas desde la Terminal.
diff --git a/web/content/features/linux-apps.meta.json b/web/content/features/linux-apps.meta.json
index f260d69..aeae0c4 100644
--- a/web/content/features/linux-apps.meta.json
+++ b/web/content/features/linux-apps.meta.json
@@ -107,9 +107,9 @@
"pt": "Seu próprio escopo de cgroup"
},
"sub": {
- "en": "Root-owned; the firewall and Monitor use it",
- "es": "De root; lo usan el firewall y el Monitor",
- "pt": "Do root; usado pelo firewall e pelo Monitor"
+ "en": "Root-owned; the firewall, its restrictions and the Monitor use it",
+ "es": "De root; lo usan el firewall, sus restricciones y el Monitor",
+ "pt": "Do root; usado pelo firewall, por suas restrições e pelo Monitor"
},
"tone": "kernel"
},
@@ -121,9 +121,9 @@
"pt": "GTK / Qt / navegador"
},
"sub": {
- "en": "Runs as you; not sandboxed",
- "es": "Corre como vos; sin caja de arena",
- "pt": "Roda como você; sem sandbox"
+ "en": "Runs as you; not sandboxed by default",
+ "es": "Corre como vos; sin caja de arena de forma predeterminada",
+ "pt": "Roda como você; sem sandbox por padrão"
},
"tone": "reused"
},
@@ -181,9 +181,9 @@
}
],
"caption": {
- "en": "Linux apps connect straight to the compositor; they get the frame, the Dock and the firewall, but not the app sandbox.",
- "es": "Las apps de Linux se conectan directo al compositor; tienen el marco, el Dock y el firewall, pero no la caja de arena de las apps.",
- "pt": "Apps Linux se conectam direto ao compositor; ganham a moldura, o Dock e o firewall, mas não o sandbox de apps."
+ "en": "Linux apps connect straight to the compositor; they get the frame, the Dock, the firewall and the restrictions you set, but not the app sandbox.",
+ "es": "Las apps de Linux se conectan directo al compositor; tienen el marco, el Dock, el firewall y las restricciones que fijes, pero no la caja de arena de las apps.",
+ "pt": "Apps Linux se conectam direto ao compositor; ganham a moldura, o Dock, o firewall e as restrições que você definir, mas não o sandbox de apps."
}
}
],
@@ -199,9 +199,17 @@
{
"path": "server/src/apps.c",
"what": {
- "en": "The .desktop launcher",
- "es": "El lanzador de .desktop",
- "pt": "O lançador de .desktop"
+ "en": "The .desktop launcher and the files restriction",
+ "es": "El lanzador de .desktop y la restricción de archivos",
+ "pt": "O lançador de .desktop e a restrição de arquivos"
+ }
+ },
+ {
+ "path": "server/src/sec/pwguard.c",
+ "what": {
+ "en": "The PipeWire guard",
+ "es": "La guardia de PipeWire",
+ "pt": "O guarda do PipeWire"
}
},
{
diff --git a/web/content/features/linux-apps.pt.md b/web/content/features/linux-apps.pt.md
index 473416f..f21e68c 100644
--- a/web/content/features/linux-apps.pt.md
+++ b/web/content/features/linux-apps.pt.md
@@ -22,7 +22,7 @@ Os apps com um arquivo `.desktop` aparecem no lançador de apps, no menu iniciar
1. A interface só pode passar o **id** de um arquivo `.desktop` já instalado em `/usr/share/applications` ou `~/.local/share/applications`, nunca um comando.
2. O `lord-server` relê esse arquivo, confere que é um aplicativo de verdade, visível e que não roda em terminal, e monta o comando a partir da linha `Exec` seguindo a especificação, sem shell e sem argumentos de quem chamou. O "Abrir com" do Arquivos pode acrescentar exatamente um arquivo, só se o app declarar os tipos de arquivo que trata e o arquivo estiver na sua pasta pessoal ou num disco que você montou.
-3. O app é iniciado no seu próprio cgroup, `app-lordos-<id>.scope`, criado pelo root, para que o Monitor e o firewall por app saibam a qual app pertence cada processo.
+3. O app é iniciado no seu próprio cgroup, `app-lordos-<id>.scope`, criado pelo root, para que o Monitor, o firewall por app e suas restrições saibam a qual app pertence cada processo. Se você restringiu os seus arquivos para o app, é aqui também que ele recebe a própria visão: namespaces próprios, uma pasta pessoal vazia só com as pastas dele, e Landlock.
O JavaScript do LordOS não consegue escrever arquivos `.desktop`, então a interface não tem como inventar um comando: ela só pode escolher um app que já está instalado.
@@ -51,11 +51,11 @@ Ausente de propósito: qualquer protocolo que permita a um app capturar a tela o
## As perguntas do leitor cético
-**Os apps Linux ficam em sandbox?** Não. Isso é importante: eles rodam como o seu usuário, como em qualquer sistema Debian, e podem ler sua pasta pessoal. O que o LordOS acrescenta é um cgroup por app, a atribuição no Monitor e o firewall por app aplicado pelo kernel (permitir, negar, só LAN, sem conexões de entrada). Só os apps `.lpk` do próprio LordOS recebem o sandbox completo.
+**Os apps Linux ficam em sandbox?** Não por padrão. Isso é importante: eles rodam como o seu usuário, como em qualquer sistema Debian, e podem ler sua pasta pessoal. O que o LordOS acrescenta é um cgroup por app, a atribuição no Monitor, o firewall por app aplicado pelo kernel (permitir, negar, só LAN, sem conexões de entrada, regras por domínio ou endereço) e restrições que você pode definir por app: sem câmera, sem USB e sem sockets Bluetooth (no kernel), sem microfone (o guarda do PipeWire do LordOS mais os nós de captura da placa de som), sem notificações e "sem acesso aos seus arquivos", aplicada a partir da próxima abertura. Elas não cobrem a área de transferência, o Bluetooth através do BlueZ no barramento do sistema nem programas iniciados fora do lançador de apps. Só os apps `.lpk` do próprio LordOS recebem o sandbox completo.
-**Um app Linux consegue ver outras janelas ou gravar a tela?** Não pelo LordOS. O compositor só entrega a um app as superfícies dele mesmo e não oferece nenhum protocolo de captura de tela, então janelas protegidas como a de Senhas também ficam privadas para eles.
+**Um app Linux consegue ver outras janelas ou gravar a tela?** Não pelo LordOS. O compositor só entrega a um app as superfícies dele mesmo e não oferece nenhum protocolo de captura de tela, não há servidor X nem portal de captura de tela, e um app restrito também tem o dispositivo de framebuffer negado, então janelas protegidas como a de Senhas também ficam privadas para eles.
-**E os apps que só falam X11?** Não rodam: o Xwayland não faz parte do LordOS. Os apps GTK e Qt atuais falam Wayland, e o jogo SDL testado também.
+**E os apps que só falam X11?** Ainda não rodam: o Xwayland não faz parte do LordOS 0.8.0 Beta. Ele está planejado antes da 1.0, com os apps X11 ganhando a mesma identidade por app, o mesmo firewall e as mesmas restrições. Os apps GTK e Qt atuais falam Wayland, e o jogo SDL testado também.
**E o Flatpak?** O LordOS não o usa nem o integra, e ele não foi testado.
@@ -63,7 +63,7 @@ Ausente de propósito: qualquer protocolo que permita a um app capturar a tela o
## Limites honestos
-- **Sem Xwayland,** então nada de apps só X11.
+- **Ainda sem Xwayland** (planejado antes da 1.0), então nada de apps só X11.
- **Ainda não:** arrastar e soltar entre apps, a seleção primária do clique do meio, os métodos de entrada do LordOS (coreano, japonês, chinês) dentro dos apps Linux e os pedidos de ativação de apps.
- **Ícones só em SVG:** o LordOS ainda não desenha SVG. Ele usa os ícones PNG que o Debian publica para a maioria dos apps, ou a inicial.
- **Apps de terminal** com arquivo `.desktop` não aparecem no lançador de apps; inicie-os pelo Terminal.
diff --git a/web/content/features/own-desktop.en.md b/web/content/features/own-desktop.en.md
index 3955544..971286a 100644
--- a/web/content/features/own-desktop.en.md
+++ b/web/content/features/own-desktop.en.md
@@ -60,7 +60,7 @@ So the compositor is the meeting point. The UI engine is used by LordOS's own in
LordOS aims at modest machines. A few real measurements from the project's test logs:
-- The final 0.7.0 Beta ISO, idle a minute after login on a 4 GB, 4-core VM: **465 MB of RAM used** for the whole system in the live session and **487 MB** on the installed system, with the CPU **99 % idle**. Boot took 16.3 s (`docs/ISO.md`, "Final ISO test").
+- The final test ISO, idle a minute after login on a 4 GB, 4-core VM: **465 MB of RAM used** for the whole system in the live session and **487 MB** on the installed system, with the CPU **99 % idle**. Boot took 16.3 s (`docs/ISO.md`, "Final ISO test").
- On a Raspberry Pi 5 (16 GB) at the login screen, without a monitor: `lord-server` at **36 MB RSS** and 0.6 % CPU (`docs/RASPBERRY.md`).
- When the machine has no 3D-capable card, `lord-server` doesn't even load Mesa and stays at about 32 MB of RSS (`docs/GPU.md`).
@@ -79,7 +79,7 @@ The compositor drives several displays at once, extended or mirrored, and draws
- **Real GPUs are not verified yet.** The GPU path was exercised with Mesa's software renderer in virtual machines. Testing on real AMD and Nvidia cards is still pending (`docs/GPU.md`).
- **Multiple displays were tested with two virtual heads**, not with real monitors, laptop panels or DisplayPort hubs (`docs/DISPLAYS.md`).
- **The Raspberry Pi 5 has not been tested with a monitor attached yet.** The build, the tests and the login screen ran on a real board without HDMI (`docs/RASPBERRY.md`).
-- **Xwayland is not part of LordOS**, so apps that only speak X11 don't run. Drag and drop between Linux apps, the primary selection and LordOS input methods inside Linux apps are pending (`docs/WAYLAND.md`).
+- **Xwayland is not part of LordOS yet** (it is planned before 1.0), so apps that only speak X11 don't run. Drag and drop between Linux apps, the primary selection and LordOS input methods inside Linux apps are pending (`docs/WAYLAND.md`).
- **Accessibility is mostly ahead of us:** today there is a "reduce motion" setting; a screen reader, zoom and high contrast are on the roadmap.
## Read the source
diff --git a/web/content/features/own-desktop.es.md b/web/content/features/own-desktop.es.md
index 085a008..26bbd17 100644
--- a/web/content/features/own-desktop.es.md
+++ b/web/content/features/own-desktop.es.md
@@ -60,7 +60,7 @@ O sea que el compositor es el punto de encuentro. El motor de interfaz lo usan l
LordOS apunta a máquinas modestas. Algunas mediciones reales de los registros de prueba del proyecto:
-- La ISO final 0.7.0 Beta, en reposo un minuto después de ingresar, en una VM de 4 GB y 4 núcleos: **465 MB de RAM usados** por todo el sistema en la sesión live y **487 MB** en el sistema instalado, con la CPU **99 % ociosa**. El arranque tardó 16,3 s (`docs/ISO.md`, "Final ISO test").
+- La ISO de la prueba final, en reposo un minuto después de ingresar, en una VM de 4 GB y 4 núcleos: **465 MB de RAM usados** por todo el sistema en la sesión live y **487 MB** en el sistema instalado, con la CPU **99 % ociosa**. El arranque tardó 16,3 s (`docs/ISO.md`, "Final ISO test").
- En una Raspberry Pi 5 (16 GB) en la pantalla de ingreso, sin monitor: `lord-server` con **36 MB de RSS** y 0,6 % de CPU (`docs/RASPBERRY.md`).
- Cuando la máquina no tiene una placa con 3D, `lord-server` ni siquiera carga Mesa y se queda en unos 32 MB de RSS (`docs/GPU.md`).
@@ -79,7 +79,7 @@ El compositor maneja varias pantallas a la vez, extendidas o en espejo, y dibuja
- **Las GPU reales todavía no están verificadas.** El camino por GPU se probó con el renderizador por software de Mesa en máquinas virtuales. Falta probar en placas AMD y Nvidia reales (`docs/GPU.md`).
- **Las pantallas múltiples se probaron con dos salidas virtuales**, no con monitores reales, paneles de notebook ni hubs DisplayPort (`docs/DISPLAYS.md`).
- **La Raspberry Pi 5 todavía no se probó con un monitor conectado.** La compilación, las pruebas y la pantalla de ingreso corrieron en una placa real sin HDMI (`docs/RASPBERRY.md`).
-- **Xwayland no es parte de LordOS**, así que las apps que solo hablan X11 no funcionan. Arrastrar y soltar entre apps de Linux, la selección primaria y los métodos de entrada de LordOS dentro de apps de Linux están pendientes (`docs/WAYLAND.md`).
+- **Xwayland todavía no es parte de LordOS** (está planeado antes de la 1.0), así que las apps que solo hablan X11 no funcionan. Arrastrar y soltar entre apps de Linux, la selección primaria y los métodos de entrada de LordOS dentro de apps de Linux están pendientes (`docs/WAYLAND.md`).
- **La accesibilidad está mayormente por delante:** hoy hay un ajuste de "reducir movimiento"; un lector de pantalla, el zoom y el alto contraste están en la hoja de ruta.
## Leé el código
diff --git a/web/content/features/own-desktop.meta.json b/web/content/features/own-desktop.meta.json
index 79c12df..11b4cb3 100644
--- a/web/content/features/own-desktop.meta.json
+++ b/web/content/features/own-desktop.meta.json
@@ -39,9 +39,9 @@
{
"file": "docs/iso-final/live-idle.png",
"caption": {
- "en": "The 0.7.0 Beta live ISO at rest on a 4 GB VM: 465 MB used and a 16.3 s boot.",
- "es": "La ISO live 0.7.0 Beta en reposo en una VM de 4 GB: 465 MB usados y un arranque de 16,3 s.",
- "pt": "A ISO live 0.7.0 Beta em repouso numa VM de 4 GB: 465 MB em uso e boot de 16,3 s."
+ "en": "The final test live ISO at rest on a 4 GB VM: 465 MB used and a 16.3 s boot.",
+ "es": "La ISO live de la prueba final en reposo en una VM de 4 GB: 465 MB usados y un arranque de 16,3 s.",
+ "pt": "A ISO live do teste final em repouso numa VM de 4 GB: 465 MB em uso e boot de 16,3 s."
}
},
{
diff --git a/web/content/features/own-desktop.pt.md b/web/content/features/own-desktop.pt.md
index 6614803..1a8a09e 100644
--- a/web/content/features/own-desktop.pt.md
+++ b/web/content/features/own-desktop.pt.md
@@ -60,7 +60,7 @@ Ou seja, o compositor é o ponto de encontro. O motor de interface é usado pela
O LordOS mira máquinas modestas. Algumas medições reais dos registros de teste do projeto:
-- A ISO final 0.7.0 Beta, ociosa um minuto após o login numa VM com 4 GB e 4 núcleos: **465 MB de RAM em uso** para o sistema inteiro na sessão live e **487 MB** no sistema instalado, com a CPU **99 % ociosa**. O boot levou 16,3 s (`docs/ISO.md`, "Final ISO test").
+- A ISO do teste final, ociosa um minuto após o login numa VM com 4 GB e 4 núcleos: **465 MB de RAM em uso** para o sistema inteiro na sessão live e **487 MB** no sistema instalado, com a CPU **99 % ociosa**. O boot levou 16,3 s (`docs/ISO.md`, "Final ISO test").
- Num Raspberry Pi 5 (16 GB), na tela de login e sem monitor: `lord-server` com **36 MB de RSS** e 0,6 % de CPU (`docs/RASPBERRY.md`).
- Quando a máquina não tem placa com 3D, o `lord-server` nem carrega o Mesa e fica em torno de 32 MB de RSS (`docs/GPU.md`).
@@ -79,7 +79,7 @@ O compositor controla várias telas ao mesmo tempo, estendidas ou espelhadas, e
- **GPUs reais ainda não foram verificadas.** O caminho da GPU foi exercitado com o renderizador por software do Mesa em máquinas virtuais. O teste em placas AMD e Nvidia reais ainda está pendente (`docs/GPU.md`).
- **Várias telas foram testadas com duas saídas virtuais**, não com monitores reais, painéis de notebook ou hubs DisplayPort (`docs/DISPLAYS.md`).
- **O Raspberry Pi 5 ainda não foi testado com um monitor conectado.** A compilação, os testes e a tela de login rodaram numa placa real sem HDMI (`docs/RASPBERRY.md`).
-- **O Xwayland não faz parte do LordOS**, então apps que só falam X11 não rodam. Arrastar e soltar entre apps Linux, a seleção primária e os métodos de entrada do LordOS dentro de apps Linux estão pendentes (`docs/WAYLAND.md`).
+- **O Xwayland ainda não faz parte do LordOS** (está planejado antes da 1.0), então apps que só falam X11 não rodam. Arrastar e soltar entre apps Linux, a seleção primária e os métodos de entrada do LordOS dentro de apps Linux estão pendentes (`docs/WAYLAND.md`).
- **A acessibilidade ainda está quase toda pela frente:** hoje existe um ajuste para "reduzir movimento"; leitor de tela, zoom e alto contraste estão no roadmap.
## Leia o código
diff --git a/web/content/features/private-by-design.en.md b/web/content/features/private-by-design.en.md
index 3e2fb4a..46dec3f 100644
--- a/web/content/features/private-by-design.en.md
+++ b/web/content/features/private-by-design.en.md
@@ -21,10 +21,10 @@ This is the first question a careful reader should ask, so here is the precise a
| Installed `.lpk` apps | yes | yes | yes, with memory and CPU limits | yes | yes |
| Passwords (the only built-in app in its own process today) | yes | yes | yes | yes | yes |
| Other built-in apps (Files, Settings, Mail, Terminal…) | no, they run inside `lord-server` | no | no (they count as "LordOS") | their camera, microphone and screen use is checked in C | yes, as "LordOS" |
-| Linux apps opened from the app launcher (apt, the Store) | yes, a normal process | **no** | yes, `app-lordos-<id>.scope`, no limits | **no** | **yes** |
+| Linux apps opened from the app launcher (apt, the Store) | yes, a normal process | **no** by default; with "no access to your files", their own namespaces and Landlock | yes, `app-lordos-<id>.scope`, no limits | **no** | **yes**, plus the restrictions you set (camera, microphone, USB, Bluetooth, files, notifications) |
| Programs started from the Terminal | yes | no | they share the Terminal's place in the tree | no | as "LordOS" |
-So: **Linux apps are not sandboxed by LordOS.** They run as your user, exactly as on any Debian system, and can read your home folder. What LordOS adds for them is attribution (the Monitor knows which app made each connection) and the kernel-enforced per-app firewall. Flatpak is not used or integrated by LordOS, and it hasn't been tested.
+So: **Linux apps are not sandboxed by default.** They run as your user, exactly as on any Debian system, and can read your home folder. What LordOS adds for them is attribution (the Monitor knows which app made each connection), the kernel-enforced per-app firewall, and the restrictions you choose for an app: no camera, no microphone, no USB, no Bluetooth sockets, no notifications, and "no access to your files", which from its next launch starts the app in its own namespaces with an empty home folder holding only its own folders. Flatpak is not used or integrated by LordOS, and it hasn't been tested.
Built-in apps are part of the system's own code, reviewed with it; they don't get the per-process isolation that third-party packages get, with Passwords as the exception because it holds your secrets.
@@ -40,7 +40,7 @@ The sandbox is LordOS's own code (`server/src/sec/sandbox.c`), not bubblewrap, F
- **A cgroup of its own**, `app-lordos-lpk-<id>.scope`, with a soft memory limit of 192 MB, a hard one of 512 MB and at most one CPU core. The scope is created and owned by root (`lord-sessiond`), so the app can't move itself elsewhere.
- **Network only with permission.** Without the `network` permission, seccomp refuses to create internet sockets and Landlock refuses TCP connect and bind. With it (declared in the manifest **and** allowed by you), they are allowed, and the per-app firewall still applies.
-**Are namespaces used?** No. `lord-server` runs without root, and creating a network namespace needs privileges it doesn't have. The design uses Landlock, seccomp and cgroups instead, and leaves the app in the machine's network namespace under the rules above.
+**Are namespaces used?** Not for `.lpk` apps. `lord-server` runs without root, and creating a network namespace needs privileges it doesn't have. The design uses Landlock, seccomp and cgroups instead, and leaves the app in the machine's network namespace under the rules above. The one place LordOS uses namespaces is a Linux app restricted with "no access to your files": it starts in its own unprivileged user, mount and PID namespaces, built by LordOS's own code in the launcher, so it can't reach the session's sockets.
The project keeps a deliberately malicious test app (`tests/lpk-evil`). It declares no permissions and tries everything at start: reading `~/.ssh/id_rsa` and `settings.json`, writing outside its folder, reading the clipboard silently, opening `/etc/shadow`, opening a socket, running `/bin/sh`, `ptrace`, opening the graphics card. Every attempt is blocked. The sandbox test suite passes 14 of 14 checks for apps, 14 of 14 with network and 17 of 17 for helpers.
@@ -58,7 +58,7 @@ Permissions an app can declare: files, clipboard, notifications, network, camera
## The skeptical reader's questions
-**Can the prompt be bypassed?** Not by the isolated app. The prompt is drawn by the session, outside the app's window. The answer reaches `lord-server` directly, and the broker reads the stored decision in C on every request. The decisions file is outside what Landlock lets the app see, and `lord.fs` refuses to write it. An app could draw a fake dialog inside its own window, but clicking it changes nothing. The honest gap: a Linux app, which isn't sandboxed and runs as you, could edit `permisos.json` like any other file in your home.
+**Can the prompt be bypassed?** Not by the isolated app. The prompt is drawn by the session, outside the app's window. The answer reaches `lord-server` directly, and the broker reads the stored decision in C on every request. The decisions file is outside what Landlock lets the app see, and `lord.fs` refuses to write it. An app could draw a fake dialog inside its own window, but clicking it changes nothing. The honest gap: a Linux app, which isn't sandboxed by default and runs as you, could edit `permisos.json` like any other file in your home, unless it is restricted with "no access to your files".
**Do I get "Allow once" or "Allow always"?** Today the prompt offers Allow and Don't Allow, and the decision is remembered until you change it in Settings. There is no "allow once" for app permissions yet.
@@ -76,6 +76,8 @@ Permissions an app can declare: files, clipboard, notifications, network, camera
[[shot:3]]
+**Can I make sure an app never gets the camera, whatever it asks?** Yes: restrict it in Settings → Privacy → App network access. A firewall restriction beats any permission: the app is refused without a prompt even if you allowed it before, and restricting a running app takes its camera and microphone away at once. For isolated apps the broker enforces all eight restrictions (camera, microphone, screen, USB, files, clipboard, Bluetooth, notifications).
+
**What about apps that need more privileges?** There is no way for a `.lpk` app to get root or extra capabilities. Everything in LordOS that needs root goes through a closed list of validated actions (`server/src/admin.c`), and JavaScript can't run arbitrary commands. Linux apps behave as on any Debian system: if a program needs `sudo`, you run it yourself in the Terminal.
## The helpers that read untrusted data
@@ -84,15 +86,14 @@ Files from outside are the classic way in. LordOS opens them in small separate p
## Protected windows
-A window can be marked protected. Passwords is. Its pixels come out black in LordOS screenshots, screen recordings, thumbnails and the remote desktop, while the real monitor shows it normally. Linux apps can't capture the screen through LordOS: the compositor doesn't offer any screen-capture protocol to them.
+A window can be marked protected. Passwords is. Its pixels come out black in LordOS screenshots, screen recordings, thumbnails and the remote desktop, while the real monitor shows it normally. Linux apps can't capture the screen through LordOS: the compositor doesn't offer any screen-capture protocol to them, there is no X server, and a restricted app is also denied the framebuffer device.
[[shot:5]]
## Honest limits
-- **Linux apps are not sandboxed.** Only network rules and attribution apply to them.
+- **Linux apps are not sandboxed by default.** Network rules, attribution and the restrictions you set apply to them; the restrictions don't cover the clipboard, Bluetooth through BlueZ on the system bus, the system bus in general, or programs started outside the app launcher.
- **Camera and microphone use by Linux apps is not shown** in the indicators yet. The Monitor's device list is planned.
-- **Some firewall "restrictions" are not enforced yet.** Settings lets you tick "no camera", "no microphone", "no screen", "no USB", "no Bluetooth", "no files" and "no notifications" for an app. They are stored, but no component checks them today; only the four network restrictions are enforced. For camera and microphone, use the permission itself (Deny), which is enforced.
- **The broker doesn't cover everything yet.** Permissions like Bluetooth or launching other apps can be declared, but there is no broker call for them, so an isolated app simply can't do those things.
- **A missing kernel feature weakens the app sandbox quietly.** If Landlock or a cgroup controller is missing, apps still start, with a warning in the log. Helpers, by contrast, refuse to run without seccomp.
@@ -102,6 +103,7 @@ A window can be marked protected. Passwords is. Its pixels come out black in Lor
- [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c): the broker, server side
- [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c): per-app permissions
- [server/src/sec/brokercam.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokercam.c): the camera for isolated apps
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c): firewall restrictions in the broker
- [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c) and [server/src/remote/cgsup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/cgsup.c): root-owned app scopes
- [server/src/app/appclient.c](https://github.com/lordbasex/LordOS/blob/main/server/src/app/appclient.c): the isolated app process
- [sdk/privacy.js](https://github.com/lordbasex/LordOS/blob/main/sdk/privacy.js) and [sdk/powerbox.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/powerbox.jsx): prompts and the file dialog
diff --git a/web/content/features/private-by-design.es.md b/web/content/features/private-by-design.es.md
index 3a0c80d..472a3bc 100644
--- a/web/content/features/private-by-design.es.md
+++ b/web/content/features/private-by-design.es.md
@@ -21,10 +21,10 @@ Es la primera pregunta que tiene que hacerse un lector cuidadoso, así que acá
| Apps `.lpk` instaladas | sí | sí | sí, con límites de memoria y CPU | sí | sí |
| Contraseñas (hoy la única app incluida con proceso propio) | sí | sí | sí | sí | sí |
| Otras apps incluidas (Archivos, Ajustes, Mail, Terminal…) | no, corren dentro de `lord-server` | no | no (cuentan como "LordOS") | su uso de cámara, micrófono y pantalla se revisa en C | sí, como "LordOS" |
-| Apps de Linux abiertas desde el lanzador de apps (apt, la Tienda) | sí, un proceso común | **no** | sí, `app-lordos-<id>.scope`, sin límites | **no** | **sí** |
+| Apps de Linux abiertas desde el lanzador de apps (apt, la Tienda) | sí, un proceso común | **no** de forma predeterminada; con "sin acceso a tus archivos", espacios de nombres propios y Landlock | sí, `app-lordos-<id>.scope`, sin límites | **no** | **sí**, más las restricciones que fijes (cámara, micrófono, USB, Bluetooth, archivos, notificaciones) |
| Programas iniciados desde la Terminal | sí | no | comparten el lugar de la Terminal en el árbol | no | como "LordOS" |
-O sea: **LordOS no encierra a las apps de Linux en una caja de arena.** Corren como tu usuario, exactamente como en cualquier sistema Debian, y pueden leer tu carpeta personal. Lo que LordOS les suma es atribución (el Monitor sabe qué app hizo cada conexión) y el firewall por app que aplica el kernel. LordOS no usa ni integra Flatpak, y no se probó.
+O sea: **LordOS no encierra a las apps de Linux en una caja de arena de forma predeterminada.** Corren como tu usuario, exactamente como en cualquier sistema Debian, y pueden leer tu carpeta personal. Lo que LordOS les suma es atribución (el Monitor sabe qué app hizo cada conexión), el firewall por app que aplica el kernel y las restricciones que elijas para una app: sin cámara, sin micrófono, sin USB, sin sockets Bluetooth, sin notificaciones y "sin acceso a tus archivos", que desde su próximo inicio abre la app en sus propios espacios de nombres, con una carpeta personal vacía que solo tiene sus propias carpetas. LordOS no usa ni integra Flatpak, y no se probó.
Las apps incluidas son parte del código propio del sistema y se revisan junto con él; no tienen el aislamiento por proceso que tienen los paquetes de terceros, con la excepción de Contraseñas, porque guarda tus secretos.
@@ -40,7 +40,7 @@ La caja de arena es código propio de LordOS (`server/src/sec/sandbox.c`), no bu
- **Un cgroup propio**, `app-lordos-lpk-<id>.scope`, con un límite blando de memoria de 192 MB, uno duro de 512 MB y como máximo un núcleo de CPU. El scope lo crea y lo tiene root (`lord-sessiond`), así que la app no se puede mudar a otro lado.
- **Red solo con permiso.** Sin el permiso `network`, seccomp se niega a crear sockets de internet y Landlock niega el connect y el bind de TCP. Con el permiso (declarado en el manifiesto **y** permitido por vos), se habilitan, y el firewall por app sigue aplicando.
-**¿Se usan namespaces?** No. `lord-server` corre sin root, y crear un namespace de red necesita privilegios que no tiene. El diseño usa Landlock, seccomp y cgroups en su lugar, y deja la app en el namespace de red de la máquina bajo las reglas de arriba.
+**¿Se usan namespaces?** No para las apps `.lpk`. `lord-server` corre sin root, y crear un namespace de red necesita privilegios que no tiene. El diseño usa Landlock, seccomp y cgroups en su lugar, y deja la app en el namespace de red de la máquina bajo las reglas de arriba. El único lugar donde LordOS usa namespaces es una app de Linux restringida con "sin acceso a tus archivos": arranca en sus propios namespaces de usuario, montaje y PID, sin privilegios, armados por código propio de LordOS en el lanzador, así que no llega a los sockets de la sesión.
El proyecto mantiene una app de prueba maliciosa a propósito (`tests/lpk-evil`). No declara permisos e intenta de todo al arrancar: leer `~/.ssh/id_rsa` y `settings.json`, escribir fuera de su carpeta, leer el portapapeles sin avisar, abrir `/etc/shadow`, abrir un socket, ejecutar `/bin/sh`, `ptrace`, abrir la placa de video. Todos los intentos quedan bloqueados. La batería de pruebas de la caja de arena pasa 14 de 14 controles para apps, 14 de 14 con red y 17 de 17 para ayudantes.
@@ -58,7 +58,7 @@ Permisos que una app puede declarar: archivos, portapapeles, notificaciones, red
## Las preguntas del lector escéptico
-**¿Se puede saltear el aviso?** La app aislada no. El aviso lo dibuja la sesión, fuera de la ventana de la app. La respuesta llega directo a `lord-server`, y el broker lee en C la decisión guardada en cada pedido. El archivo de decisiones está fuera de lo que Landlock le deja ver a la app, y `lord.fs` se niega a escribirlo. Una app podría dibujar un diálogo falso dentro de su propia ventana, pero tocarlo no cambia nada. El hueco honesto: una app de Linux, que no está en caja de arena y corre como vos, podría editar `permisos.json` como cualquier otro archivo de tu carpeta personal.
+**¿Se puede saltear el aviso?** La app aislada no. El aviso lo dibuja la sesión, fuera de la ventana de la app. La respuesta llega directo a `lord-server`, y el broker lee en C la decisión guardada en cada pedido. El archivo de decisiones está fuera de lo que Landlock le deja ver a la app, y `lord.fs` se niega a escribirlo. Una app podría dibujar un diálogo falso dentro de su propia ventana, pero tocarlo no cambia nada. El hueco honesto: una app de Linux, que de forma predeterminada no está en caja de arena y corre como vos, podría editar `permisos.json` como cualquier otro archivo de tu carpeta personal, salvo que esté restringida con "sin acceso a tus archivos".
**¿Tengo "Permitir una vez" o "Permitir siempre"?** Hoy el aviso ofrece Permitir y No permitir, y la decisión se recuerda hasta que la cambies en Ajustes. Todavía no hay "permitir una vez" para los permisos de las apps.
@@ -76,6 +76,8 @@ Permisos que una app puede declarar: archivos, portapapeles, notificaciones, red
[[shot:3]]
+**¿Puedo asegurarme de que una app nunca reciba la cámara, pida lo que pida?** Sí: restringila en Ajustes → Privacidad → Red de las apps. Una restricción del firewall les gana a los permisos: la app recibe un rechazo sin aviso aunque antes la hayas permitido, y restringir una app en marcha le quita la cámara y el micrófono al instante. Para las apps aisladas, el broker aplica las ocho restricciones (cámara, micrófono, pantalla, USB, archivos, portapapeles, Bluetooth, notificaciones).
+
**¿Y las apps que necesitan más privilegios?** No hay forma de que una app `.lpk` obtenga root ni capacidades extra. Todo lo que en LordOS necesita root pasa por una lista cerrada de acciones validadas (`server/src/admin.c`), y JavaScript no puede ejecutar comandos arbitrarios. Las apps de Linux se comportan como en cualquier sistema Debian: si un programa necesita `sudo`, lo corrés vos en la Terminal.
## Los ayudantes que leen datos no confiables
@@ -84,15 +86,14 @@ Los archivos que vienen de afuera son la puerta de entrada clásica. LordOS los
## Ventanas protegidas
-Una ventana se puede marcar como protegida. La de Contraseñas lo está. Sus píxeles salen en negro en las capturas de LordOS, las grabaciones de pantalla, las miniaturas y el escritorio remoto, mientras el monitor real la muestra normal. Las apps de Linux no pueden capturar la pantalla a través de LordOS: el compositor no les ofrece ningún protocolo de captura.
+Una ventana se puede marcar como protegida. La de Contraseñas lo está. Sus píxeles salen en negro en las capturas de LordOS, las grabaciones de pantalla, las miniaturas y el escritorio remoto, mientras el monitor real la muestra normal. Las apps de Linux no pueden capturar la pantalla a través de LordOS: el compositor no les ofrece ningún protocolo de captura, no hay servidor X, y a una app restringida también se le niega el dispositivo de framebuffer.
[[shot:5]]
## Límites honestos
-- **Las apps de Linux no están en caja de arena.** A ellas solo se les aplican las reglas de red y la atribución.
+- **Las apps de Linux no están en caja de arena de forma predeterminada.** Se les aplican las reglas de red, la atribución y las restricciones que fijes; las restricciones no cubren el portapapeles, el Bluetooth a través de BlueZ en el bus del sistema, el bus del sistema en general ni los programas iniciados fuera del lanzador de apps.
- **El uso de cámara y micrófono por apps de Linux todavía no se muestra** en los indicadores. La lista de dispositivos del Monitor está planeada.
-- **Algunas "restricciones" del firewall todavía no se aplican.** Ajustes te deja marcar "sin cámara", "sin micrófono", "sin captura de pantalla", "sin USB", "sin Bluetooth", "sin archivos fuera del selector" y "sin notificaciones" para una app. Se guardan, pero hoy ningún componente las revisa; solo se aplican las cuatro restricciones de red. Para la cámara y el micrófono, usá el permiso en sí (Denegar), que sí se aplica.
- **El broker todavía no cubre todo.** Permisos como Bluetooth o abrir otras apps se pueden declarar, pero no hay una llamada del broker para ellos, así que una app aislada directamente no puede hacer esas cosas.
- **Si falta una función del kernel, la caja de arena de las apps se debilita sin hacer ruido.** Si faltan Landlock o un controlador de cgroup, las apps igual arrancan, con una advertencia en el registro. Los ayudantes, en cambio, se niegan a correr sin seccomp.
@@ -102,6 +103,7 @@ Una ventana se puede marcar como protegida. La de Contraseñas lo está. Sus pí
- [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c): el broker, del lado del servidor
- [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c): permisos por app
- [server/src/sec/brokercam.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokercam.c): la cámara para apps aisladas
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c): las restricciones del firewall en el broker
- [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c) y [server/src/remote/cgsup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/cgsup.c): scopes de las apps en manos de root
- [server/src/app/appclient.c](https://github.com/lordbasex/LordOS/blob/main/server/src/app/appclient.c): el proceso de la app aislada
- [sdk/privacy.js](https://github.com/lordbasex/LordOS/blob/main/sdk/privacy.js) y [sdk/powerbox.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/powerbox.jsx): los avisos y el diálogo de archivos
diff --git a/web/content/features/private-by-design.meta.json b/web/content/features/private-by-design.meta.json
index 821990a..006c990 100644
--- a/web/content/features/private-by-design.meta.json
+++ b/web/content/features/private-by-design.meta.json
@@ -439,6 +439,14 @@
"pt": "Câmera para apps isolados"
}
},
+ {
+ "path": "server/src/sec/restrict.c",
+ "what": {
+ "en": "Firewall restrictions in the broker",
+ "es": "Restricciones del firewall en el broker",
+ "pt": "Restrições do firewall no broker"
+ }
+ },
{
"path": "server/src/sec/cgroup.c",
"what": {
diff --git a/web/content/features/private-by-design.pt.md b/web/content/features/private-by-design.pt.md
index 4ea2d4a..6679333 100644
--- a/web/content/features/private-by-design.pt.md
+++ b/web/content/features/private-by-design.pt.md
@@ -21,10 +21,10 @@ Esta é a primeira pergunta que um leitor atento deve fazer, então aqui vai a r
| Apps `.lpk` instalados | sim | sim | sim, com limites de memória e CPU | sim | sim |
| Senhas (hoje o único app incluído com processo próprio) | sim | sim | sim | sim | sim |
| Outros apps incluídos (Arquivos, Ajustes, E-mail, Terminal…) | não, rodam dentro do `lord-server` | não | não (contam como "LordOS") | o uso de câmera, microfone e tela é conferido em C | sim, como "LordOS" |
-| Apps Linux abertos pelo lançador de apps (apt, a Loja) | sim, um processo comum | **não** | sim, `app-lordos-<id>.scope`, sem limites | **não** | **sim** |
+| Apps Linux abertos pelo lançador de apps (apt, a Loja) | sim, um processo comum | **não** por padrão; com "sem acesso aos seus arquivos", namespaces próprios e Landlock | sim, `app-lordos-<id>.scope`, sem limites | **não** | **sim**, mais as restrições que você definir (câmera, microfone, USB, Bluetooth, arquivos, notificações) |
| Programas iniciados pelo Terminal | sim | não | dividem o lugar do Terminal na árvore | não | como "LordOS" |
-Ou seja: **os apps Linux não ficam em sandbox no LordOS.** Eles rodam como o seu usuário, exatamente como em qualquer sistema Debian, e podem ler sua pasta pessoal. O que o LordOS acrescenta para eles é a atribuição (o Monitor sabe qual app fez cada conexão) e o firewall por app aplicado pelo kernel. O Flatpak não é usado nem integrado pelo LordOS, e não foi testado.
+Ou seja: **os apps Linux não ficam em sandbox por padrão.** Eles rodam como o seu usuário, exatamente como em qualquer sistema Debian, e podem ler sua pasta pessoal. O que o LordOS acrescenta para eles é a atribuição (o Monitor sabe qual app fez cada conexão), o firewall por app aplicado pelo kernel e as restrições que você escolher para um app: sem câmera, sem microfone, sem USB, sem sockets Bluetooth, sem notificações e "sem acesso aos seus arquivos", que a partir da próxima abertura inicia o app em namespaces próprios, com uma pasta pessoal vazia que só tem as pastas dele. O Flatpak não é usado nem integrado pelo LordOS, e não foi testado.
Os apps incluídos fazem parte do código do próprio sistema, revisado junto com ele; eles não recebem o isolamento por processo que os pacotes de terceiros recebem, com Senhas como exceção, porque guarda seus segredos.
@@ -40,7 +40,7 @@ O sandbox é código próprio do LordOS (`server/src/sec/sandbox.c`), não bubbl
- **Um cgroup próprio**, `app-lordos-lpk-<id>.scope`, com limite suave de memória de 192 MB, limite rígido de 512 MB e no máximo um núcleo de CPU. O escopo é criado pelo root (`lord-sessiond`) e pertence a ele, então o app não consegue se mudar para outro lugar.
- **Rede só com permissão.** Sem a permissão `network`, o seccomp recusa criar sockets de internet e o Landlock recusa connect e bind TCP. Com ela (declarada no manifesto **e** permitida por você), eles são liberados, e o firewall por app continua valendo.
-**São usados namespaces?** Não. O `lord-server` roda sem root, e criar um namespace de rede exige privilégios que ele não tem. O projeto usa Landlock, seccomp e cgroups no lugar disso, e deixa o app no namespace de rede da máquina, sob as regras acima.
+**São usados namespaces?** Não para os apps `.lpk`. O `lord-server` roda sem root, e criar um namespace de rede exige privilégios que ele não tem. O projeto usa Landlock, seccomp e cgroups no lugar disso, e deixa o app no namespace de rede da máquina, sob as regras acima. O único lugar em que o LordOS usa namespaces é um app Linux restrito com "sem acesso aos seus arquivos": ele inicia em namespaces próprios de usuário, montagem e PID, sem privilégios, montados por código próprio do LordOS no lançador, então não alcança os sockets da sessão.
O projeto mantém um app de teste propositalmente malicioso (`tests/lpk-evil`). Ele não declara nenhuma permissão e tenta de tudo ao abrir: ler `~/.ssh/id_rsa` e `settings.json`, escrever fora da própria pasta, ler a área de transferência escondido, abrir `/etc/shadow`, abrir um socket, executar `/bin/sh`, `ptrace`, abrir a placa de vídeo. Todas as tentativas são bloqueadas. A suíte de testes do sandbox passa em 14 de 14 verificações para apps, 14 de 14 com rede e 17 de 17 para os ajudantes.
@@ -58,7 +58,7 @@ Permissões que um app pode declarar: arquivos, área de transferência, notific
## As perguntas do leitor cético
-**Dá para contornar o aviso?** Não pelo app isolado. O aviso é desenhado pela sessão, fora da janela do app. A resposta chega diretamente ao `lord-server`, e o broker lê a decisão salva, em C, a cada pedido. O arquivo de decisões fica fora do que o Landlock deixa o app ver, e o `lord.fs` se recusa a escrevê-lo. Um app até poderia desenhar um diálogo falso dentro da própria janela, mas clicar nele não muda nada. A brecha, sendo honesto: um app Linux, que não tem sandbox e roda como você, poderia editar o `permisos.json` como qualquer outro arquivo da sua pasta pessoal.
+**Dá para contornar o aviso?** Não pelo app isolado. O aviso é desenhado pela sessão, fora da janela do app. A resposta chega diretamente ao `lord-server`, e o broker lê a decisão salva, em C, a cada pedido. O arquivo de decisões fica fora do que o Landlock deixa o app ver, e o `lord.fs` se recusa a escrevê-lo. Um app até poderia desenhar um diálogo falso dentro da própria janela, mas clicar nele não muda nada. A brecha, sendo honesto: um app Linux, que por padrão não tem sandbox e roda como você, poderia editar o `permisos.json` como qualquer outro arquivo da sua pasta pessoal, a menos que esteja restrito com "sem acesso aos seus arquivos".
**Existe "Permitir uma vez" ou "Permitir sempre"?** Hoje o aviso oferece Permitir e Não permitir, e a decisão fica lembrada até você mudá-la em Ajustes. Ainda não há "permitir uma vez" para as permissões dos apps.
@@ -76,6 +76,8 @@ Permissões que um app pode declarar: arquivos, área de transferência, notific
[[shot:3]]
+**Posso garantir que um app nunca receba a câmera, peça o que pedir?** Sim: restrinja-o em Ajustes → Privacidade → Rede dos apps. Uma restrição do firewall vence as permissões: o app é recusado sem aviso mesmo que você o tenha permitido antes, e restringir um app em execução tira dele a câmera e o microfone na hora. Para os apps isolados, o broker aplica as oito restrições (câmera, microfone, tela, USB, arquivos, área de transferência, Bluetooth, notificações).
+
**E os apps que precisam de mais privilégios?** Não há como um app `.lpk` obter root ou capacidades extras. Tudo no LordOS que precisa de root passa por uma lista fechada de ações validadas (`server/src/admin.c`), e o JavaScript não consegue executar comandos arbitrários. Os apps Linux se comportam como em qualquer sistema Debian: se um programa precisa de `sudo`, você mesmo o executa no Terminal.
## Os ajudantes que leem dados não confiáveis
@@ -84,15 +86,14 @@ Arquivos vindos de fora são a porta de entrada clássica. O LordOS os abre em p
## Janelas protegidas
-Uma janela pode ser marcada como protegida. A de Senhas é. Os pixels dela saem pretos nas capturas de tela do LordOS, nas gravações de tela, nas miniaturas e na área de trabalho remota, enquanto o monitor de verdade a mostra normalmente. Os apps Linux não conseguem capturar a tela pelo LordOS: o compositor não oferece a eles nenhum protocolo de captura de tela.
+Uma janela pode ser marcada como protegida. A de Senhas é. Os pixels dela saem pretos nas capturas de tela do LordOS, nas gravações de tela, nas miniaturas e na área de trabalho remota, enquanto o monitor de verdade a mostra normalmente. Os apps Linux não conseguem capturar a tela pelo LordOS: o compositor não oferece a eles nenhum protocolo de captura de tela, não há servidor X, e um app restrito também tem o dispositivo de framebuffer negado.
[[shot:5]]
## Limites honestos
-- **Os apps Linux não têm sandbox.** Para eles valem apenas as regras de rede e a atribuição.
+- **Os apps Linux não têm sandbox por padrão.** Para eles valem as regras de rede, a atribuição e as restrições que você definir; as restrições não cobrem a área de transferência, o Bluetooth através do BlueZ no barramento do sistema, o barramento do sistema em geral nem programas iniciados fora do lançador de apps.
- **O uso de câmera e microfone por apps Linux ainda não aparece** nos indicadores. A lista de dispositivos do Monitor está planejada.
-- **Algumas "restrições" do firewall ainda não são aplicadas.** Ajustes deixa marcar "Sem câmera", "Sem microfone", "Sem captura de tela", "Sem USB", "Sem Bluetooth", "Sem arquivos fora do seletor" e "Sem notificações" para um app. Elas ficam salvas, mas hoje nenhum componente as confere; só as quatro restrições de rede são aplicadas. Para câmera e microfone, use a própria permissão (Negar), que é aplicada.
- **O broker ainda não cobre tudo.** Permissões como Bluetooth ou abrir outros apps podem ser declaradas, mas não há chamada do broker para elas, então um app isolado simplesmente não consegue fazer essas coisas.
- **A falta de um recurso do kernel enfraquece o sandbox dos apps sem alarde.** Se faltar o Landlock ou um controlador de cgroup, os apps iniciam mesmo assim, com um aviso no log. Já os ajudantes se recusam a rodar sem seccomp.
@@ -102,6 +103,7 @@ Uma janela pode ser marcada como protegida. A de Senhas é. Os pixels dela saem
- [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c): o broker, lado do servidor
- [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c): permissões por app
- [server/src/sec/brokercam.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokercam.c): a câmera para apps isolados
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c): as restrições do firewall no broker
- [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c) e [server/src/remote/cgsup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/cgsup.c): escopos dos apps que pertencem ao root
- [server/src/app/appclient.c](https://github.com/lordbasex/LordOS/blob/main/server/src/app/appclient.c): o processo do app isolado
- [sdk/privacy.js](https://github.com/lordbasex/LordOS/blob/main/sdk/privacy.js) e [sdk/powerbox.jsx](https://github.com/lordbasex/LordOS/blob/main/sdk/powerbox.jsx): avisos e o diálogo de arquivos
diff --git a/web/content/features/visible-firewall.en.md b/web/content/features/visible-firewall.en.md
index 018a71e..3d1c6c3 100644
--- a/web/content/features/visible-firewall.en.md
+++ b/web/content/features/visible-firewall.en.md
@@ -14,7 +14,7 @@ Picture a building with a guard at every apartment door instead of one at the st
- **Settings → Privacy → App network access** has a mode and two lists:
- **Silent** (the default): whatever has no rule is allowed and recorded, so you can review it in the Monitor. **Off**: only your explicit denials and restrictions apply.
- **Trusted apps**: allowed without recording. An explicit denial you set still wins.
- - **Restricted apps**: tick what an app may not do. The network restrictions are **no internet** (LAN only), **no LAN**, **no network at all** and **no incoming connections**.
+ - **Restricted apps**: tick what an app may not do. The network restrictions are **no internet** (LAN only), **no LAN**, **no network at all** and **no incoming connections**. The others take away devices and data (see [Beyond the network](#beyond-the-network)).
[[shot:1]]
@@ -24,7 +24,7 @@ Picture a building with a guard at every apartment door instead of one at the st
**1. Every app has a name the kernel can see.** When you open a Linux app from the app launcher, `lord-server` asks root to place it in its own cgroup, `app-lordos-<id>.scope`. Installed `.lpk` apps get `app-lordos-lpk-<id>.scope`. These scopes are created and owned by root, so an app can't move itself to another one.
-**2. A small root service enforces the rules.** `lord-netperm` loads seven eBPF programs into the cgroup of the LordOS service, which contains every session:
+**2. A small root service enforces the rules.** `lord-netperm` loads its eBPF programs into the cgroup of the LordOS service, which contains every session:
| Kernel hook | What it checks |
|---|---|
@@ -32,6 +32,8 @@ Picture a building with a guard at every apartment door instead of one at the st
| `sendmsg4`, `sendmsg6` | UDP sent with an address |
| `bind4`, `bind6` | incoming: "no incoming connections" and inbound rules |
| `sock_create` | "no network": the app can't even create an internet socket |
+| `cgroup/dev` | a Linux app's camera, USB, ALSA capture and framebuffer devices, on `open()` |
+| LSM `socket_create` | a Linux app's Bluetooth sockets |
Each program finds which app the calling process belongs to (by the cgroup ancestor at the scope level, so child processes count as the same app), decides, and returns allow or deny. A denied app gets `EPERM`, "Operation not permitted".
@@ -49,7 +51,19 @@ The engine does, with care about where names come from. A connection only carrie
On the test VM, "deny everything except example.com" let `https://example.com` through and denied `https://www.debian.org`, 20 out of 20 times even with an empty resolver cache. An app that uses its own DNS-over-HTTPS gets addresses the firewall never learned, so under such a rule they are denied.
-What is **not** there yet: a screen to write domain rules. The rule engine and the `lord.fw.addRule` API support domains, wildcards, networks, ports and protocols, but the interface today offers the per-app switch and the restriction lists. Per-destination switches in the Monitor are planned.
+**Where you write them.** Settings → Privacy → **Network rules by app** shows each app's default ("Allow all" or "Block all except rules") and its rules in the order they win, since the most specific one wins, with when each one last matched. The sheet that adds a rule takes an exact domain, `*.domain`, an address or a network, with an optional port and protocol, and checks what you type as you type it. In **Monitor → Network**, "Allow this domain" or "Block this domain" on one of an app's destinations opens the same sheet, prefilled with the name the system resolver gave for that address.
+
+**The honest catch: encrypted DNS.** A browser that resolves names itself over DNS over HTTPS never asks the system resolver, so its names aren't learned. "Allow only example.com" still holds (the addresses it gets were never learned, so they are blocked), but "Block example.com" doesn't stop it. Address and network rules, the app's default and its restrictions still apply, and Settings says so under the rules.
+
+## Beyond the network
+
+The same Restricted apps list can also take away the camera, the microphone, the screen, USB, your files, the clipboard, Bluetooth and notifications. A restriction beats any permission you granted before: the app is refused without a prompt, and restricting a running app takes its camera and microphone away at once. Each one is enforced where the resource is handed out:
+
+[[diagram:restrictions]]
+
+- **LordOS's isolated apps** (`.lpk` apps and Passwords): all eight, in the broker that already mediates everything they get.
+- **Built-in apps** (the "LordOS" row): camera, microphone, screen and notifications. That row is the desktop itself, so files, USB, clipboard and Bluetooth are restricted per app instead.
+- **Linux apps opened from the app launcher:** the camera, USB, ALSA capture and framebuffer devices are refused in the kernel (`cgroup/dev`); Bluetooth sockets by a BPF LSM program; the microphone and PipeWire cameras by LordOS's PipeWire guard, live, with each client identified by its socket's credentials; notifications by LordOS's notification server, which asks the bus who is calling and drops the notification if it can't tell; and "no access to your files" starts the app, from its next launch, in its own namespaces with an empty home folder and Landlock. Screen capture was never available to them: there is no capture protocol and no X server.
## The skeptical reader's questions
@@ -61,7 +75,7 @@ What is **not** there yet: a screen to write domain rules. The rule engine and t
**Can I allow a connection just once, or be asked?** The rule engine knows three durations (forever, until the app quits, just once) and an "ask" mode, but the ask prompt isn't built yet: today "ask" behaves like silent. It is designed as a retry prompt: the first connection is denied, you get *Allow once / Always / Deny*, and the app's retry goes through.
-**What happens if the service stops?** Its links are closed and everything is allowed. The desktop doesn't depend on it. On the final ISO the service was running with its seven programs attached.
+**What happens if the service stops?** Its links are closed and everything is allowed. The desktop doesn't depend on it. On the final ISO the service was running with its seven network programs attached.
**Is the service itself dangerous?** It is kept small on purpose: it runs no programs, takes no arguments, has no internet sockets of its own (its unit only allows Unix and packet sockets), and accepts one message type. It uses its own loader over the `bpf()` system call, with the programs compiled into the binary; no libbpf or bcc.
@@ -70,18 +84,20 @@ What is **not** there yet: a screen to write domain rules. The rule engine and t
- **ICMP** (ping) is only blocked by "no network". **Incoming connections to a port that is already open**, and `listen` without `bind`, aren't checked: that would need a per-packet hook.
- **The `user@` union is coarse:** while a restricted app runs, every process in that user's systemd manager is held to the union of restrictions.
- **A brand-new scope** is registered within microseconds, but a connection made before that would pass under default rules.
-- **Host names aren't shown in the Monitor yet**, only IPs and countries. The Monitor never does reverse DNS, so no address leaves the machine just because you looked at it.
-- **Non-network restrictions** (camera, microphone, screen, USB, Bluetooth, files, notifications) can be ticked in Settings but **aren't enforced yet**: only the four network restrictions are. Use the per-app permissions for the camera and the microphone.
-- **The rules file can be edited by unsandboxed Linux apps**, since they run as you. Installed `.lpk` apps can't reach it.
+- **The Monitor lists destinations as IPs and countries;** the name the system resolver gave appears when you open "Allow / Block this domain". The Monitor never does reverse DNS, so no address leaves the machine just because you looked at it.
+- **Domain rules don't see apps that use their own encrypted DNS** (see above).
+- **What the restrictions don't cover for Linux apps:** Bluetooth through BlueZ on the system bus (only raw Bluetooth sockets are refused), the system bus in general, the clipboard, and programs started outside the app launcher. A new PipeWire client of a restricted app has a few milliseconds before the guard restricts it, and while a camera- or Bluetooth-restricted app runs, your own audio services can't open a new camera or Bluetooth socket either.
+- **The rules file can be edited by unsandboxed Linux apps**, since they run as you, unless they are restricted with "no access to your files". Installed `.lpk` apps can't reach it.
## Read the source
-- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c): the seven cgroup eBPF programs
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c): the cgroup and LSM eBPF programs
- [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c): the root service
- [server/src/netperm/npcompile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npcompile.c): rules into kernel maps
- [server/src/netperm/npdns.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npdns.c): names from the system resolver
- [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c): rules, precedence and the strict file reader
- [server/src/ui/js_fw.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_fw.c): `lord.fw`, the session API
-- [apps/monitor/Firewall.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/Firewall.jsx): the Settings section
+- [apps/monitor/Firewall.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/Firewall.jsx) and [apps/monitor/FwRules.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/FwRules.jsx): the Settings sections
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c) and [server/src/sec/pwguard.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/pwguard.c): restrictions in the broker, and the PipeWire guard
- [server/tests/netperm_integration.sh](https://github.com/lordbasex/LordOS/blob/main/server/tests/netperm_integration.sh): the kernel test, 18 of 18
- [docs/FIREWALL.md](https://github.com/lordbasex/LordOS/blob/main/docs/FIREWALL.md) and [docs/MONITOR.md](https://github.com/lordbasex/LordOS/blob/main/docs/MONITOR.md)
diff --git a/web/content/features/visible-firewall.es.md b/web/content/features/visible-firewall.es.md
index 6c226a5..a0e4d9b 100644
--- a/web/content/features/visible-firewall.es.md
+++ b/web/content/features/visible-firewall.es.md
@@ -14,7 +14,7 @@ Imaginate un edificio con un guardia en la puerta de cada departamento en lugar
- **Ajustes → Privacidad → Red de las apps** tiene un modo y dos listas:
- **Silencioso** (el predeterminado): lo que no tiene regla se permite y se registra, para que lo revises en el Monitor. **Apagado**: solo valen tus denegaciones explícitas y las restricciones.
- **Apps confiables**: se permiten sin registrar. Una denegación explícita que pongas igual gana.
- - **Apps restringidas**: marcás lo que una app no puede hacer. Las restricciones de red son **sin internet** (solo LAN), **sin LAN**, **sin red** y **sin conexiones entrantes**.
+ - **Apps restringidas**: marcás lo que una app no puede hacer. Las restricciones de red son **sin internet** (solo LAN), **sin LAN**, **sin red** y **sin conexiones entrantes**. Las demás quitan dispositivos y datos (ver [Más allá de la red](#mas-alla-de-la-red)).
[[shot:1]]
@@ -24,7 +24,7 @@ Imaginate un edificio con un guardia en la puerta de cada departamento en lugar
**1. Cada app tiene un nombre que el kernel puede ver.** Cuando abrís una app de Linux desde el lanzador de apps, `lord-server` le pide a root que la ubique en su propio cgroup, `app-lordos-<id>.scope`. Las apps `.lpk` instaladas reciben `app-lordos-lpk-<id>.scope`. Estos scopes los crea y los tiene root, así que una app no se puede mudar a otro.
-**2. Un servicio root chico aplica las reglas.** `lord-netperm` carga siete programas eBPF en el cgroup del servicio de LordOS, que contiene todas las sesiones:
+**2. Un servicio root chico aplica las reglas.** `lord-netperm` carga sus programas eBPF en el cgroup del servicio de LordOS, que contiene todas las sesiones:
| Gancho del kernel | Qué revisa |
|---|---|
@@ -32,6 +32,8 @@ Imaginate un edificio con un guardia en la puerta de cada departamento en lugar
| `sendmsg4`, `sendmsg6` | UDP enviado con una dirección |
| `bind4`, `bind6` | entrantes: "sin conexiones entrantes" y reglas de entrada |
| `sock_create` | "sin red": la app ni siquiera puede crear un socket de internet |
+| `cgroup/dev` | los dispositivos de cámara, USB, captura ALSA y framebuffer de una app de Linux, en `open()` |
+| LSM `socket_create` | los sockets Bluetooth de una app de Linux |
Cada programa averigua a qué app pertenece el proceso que llama (por el cgroup ancestro al nivel del scope, así que los procesos hijos cuentan como la misma app), decide y devuelve permitir o denegar. Una app denegada recibe `EPERM`, "Operation not permitted".
@@ -49,7 +51,19 @@ El motor sí, con cuidado sobre de dónde salen los nombres. Una conexión solo
En la VM de prueba, "denegar todo menos example.com" dejó pasar `https://example.com` y denegó `https://www.debian.org`, 20 de 20 veces incluso con la caché del resolvedor vacía. Una app que usa su propio DNS sobre HTTPS obtiene direcciones que el firewall nunca aprendió, así que bajo una regla así quedan denegadas.
-Lo que **todavía no** está: una pantalla para escribir reglas por dominio. El motor de reglas y la API `lord.fw.addRule` soportan dominios, comodines, redes, puertos y protocolos, pero la interfaz hoy ofrece el interruptor por app y las listas de restricciones. Los interruptores por destino en el Monitor están planeados.
+**Dónde se escriben.** Ajustes → Privacidad → **Reglas de red por app** muestra el valor predeterminado de cada app ("Permitir todo" o "Bloquear todo salvo las reglas") y sus reglas en el orden en que ganan, porque gana la más específica, con cuándo coincidió cada una por última vez. La hoja para agregar una regla acepta un dominio exacto, `*.dominio`, una dirección o una red, con un puerto y un protocolo opcionales, y revisa lo que escribís mientras lo escribís. En **Monitor → Red**, "Permitir este dominio" o "Bloquear este dominio" sobre un destino de una app abre la misma hoja, completada con el nombre que dio el resolvedor del sistema para esa dirección.
+
+**La trampa, dicha con honestidad: el DNS cifrado.** Un navegador que resuelve nombres por su cuenta con DNS sobre HTTPS nunca le pregunta al resolvedor del sistema, así que sus nombres no se aprenden. "Permitir solo example.com" se sigue cumpliendo (las direcciones que obtiene nunca se aprendieron, así que se bloquean), pero "Bloquear example.com" no lo frena. Las reglas por dirección y por red, el valor predeterminado de la app y sus restricciones siguen valiendo, y Ajustes lo dice debajo de las reglas.
+
+## Más allá de la red
+
+La misma lista de apps restringidas también puede quitar la cámara, el micrófono, la pantalla, el USB, tus archivos, el portapapeles, el Bluetooth y las notificaciones. Una restricción les gana a los permisos que hayas dado antes: la app recibe un rechazo sin aviso, y restringir una app en marcha le quita la cámara y el micrófono al instante. Cada una se aplica donde se entrega el recurso:
+
+[[diagram:restrictions]]
+
+- **Las apps aisladas de LordOS** (apps `.lpk` y Contraseñas): las ocho, en el broker que ya media todo lo que reciben.
+- **Las apps incluidas** (la fila "LordOS"): cámara, micrófono, pantalla y notificaciones. Esa fila es el escritorio mismo, así que archivos, USB, portapapeles y Bluetooth se restringen por app.
+- **Las apps de Linux abiertas desde el lanzador de apps:** los dispositivos de cámara, USB, captura ALSA y framebuffer se rechazan en el kernel (`cgroup/dev`); los sockets Bluetooth, con un programa BPF LSM; el micrófono y las cámaras de PipeWire, con la guardia de PipeWire de LordOS, en vivo, identificando a cada cliente por las credenciales de su socket; las notificaciones, con el servidor de notificaciones de LordOS, que le pregunta al bus quién llama y descarta la notificación si no lo puede saber; y "sin acceso a tus archivos" abre la app, desde su próximo inicio, en sus propios espacios de nombres con una carpeta personal vacía y Landlock. La captura de pantalla nunca estuvo a su alcance: no hay protocolo de captura ni servidor X.
## Las preguntas del lector escéptico
@@ -61,7 +75,7 @@ Lo que **todavía no** está: una pantalla para escribir reglas por dominio. El
**¿Puedo permitir una conexión una sola vez, o que me pregunte?** El motor de reglas conoce tres duraciones (para siempre, hasta que la app se cierre, una sola vez) y un modo "preguntar", pero el aviso de preguntar todavía no está hecho: hoy "preguntar" se comporta como silencioso. Está diseñado como un aviso de reintento: la primera conexión se deniega, te aparece *Permitir una vez / Siempre / Denegar*, y el reintento de la app pasa.
-**¿Qué pasa si el servicio se detiene?** Se cierran sus enganches y todo queda permitido. El escritorio no depende de él. En la ISO final el servicio estaba corriendo con sus siete programas enganchados.
+**¿Qué pasa si el servicio se detiene?** Se cierran sus enganches y todo queda permitido. El escritorio no depende de él. En la ISO final el servicio estaba corriendo con sus siete programas de red enganchados.
**¿El servicio en sí es peligroso?** Se lo mantiene chico a propósito: no ejecuta programas, no recibe argumentos, no tiene sockets de internet propios (su unidad solo permite sockets Unix y de paquetes) y acepta un solo tipo de mensaje. Usa su propio cargador sobre la llamada al sistema `bpf()`, con los programas compilados dentro del binario; sin libbpf ni bcc.
@@ -70,18 +84,20 @@ Lo que **todavía no** está: una pantalla para escribir reglas por dominio. El
- **ICMP** (ping) solo se bloquea con "sin red". **Las conexiones entrantes a un puerto que ya está abierto**, y `listen` sin `bind`, no se revisan: eso necesitaría un gancho por paquete.
- **La unión de `user@` es gruesa:** mientras corre una app restringida, cada proceso del gestor systemd de ese usuario queda sujeto a la unión de restricciones.
- **Un scope recién creado** se registra en microsegundos, pero una conexión hecha antes pasaría con las reglas predeterminadas.
-- **Los nombres de host todavía no se muestran en el Monitor**, solo IPs y países. El Monitor nunca hace DNS inverso, así que ninguna dirección sale de la máquina solo porque la miraste.
-- **Las restricciones que no son de red** (cámara, micrófono, pantalla, USB, Bluetooth, archivos, notificaciones) se pueden marcar en Ajustes pero **todavía no se aplican**: solo se aplican las cuatro restricciones de red. Para la cámara y el micrófono, usá los permisos por app.
-- **Las apps de Linux sin caja de arena pueden editar el archivo de reglas**, porque corren como vos. Las apps `.lpk` instaladas no llegan a él.
+- **El Monitor lista los destinos como IPs y países;** el nombre que dio el resolvedor del sistema aparece cuando abrís "Permitir / Bloquear este dominio". El Monitor nunca hace DNS inverso, así que ninguna dirección sale de la máquina solo porque la miraste.
+- **Las reglas por dominio no ven a las apps que usan su propio DNS cifrado** (ver arriba).
+- **Lo que las restricciones no cubren para las apps de Linux:** el Bluetooth a través de BlueZ en el bus del sistema (solo se rechazan los sockets Bluetooth directos), el bus del sistema en general, el portapapeles y los programas iniciados fuera del lanzador de apps. Un cliente nuevo de PipeWire de una app restringida tiene unos milisegundos antes de que la guardia lo restrinja, y mientras corre una app con la cámara o el Bluetooth restringidos, tus propios servicios de audio tampoco pueden abrir una cámara ni un socket Bluetooth nuevos.
+- **Las apps de Linux sin caja de arena pueden editar el archivo de reglas**, porque corren como vos, salvo que estén restringidas con "sin acceso a tus archivos". Las apps `.lpk` instaladas no llegan a él.
## Leé el código
-- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c): los siete programas eBPF de cgroup
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c): los programas eBPF de cgroup y LSM
- [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c): el servicio root
- [server/src/netperm/npcompile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npcompile.c): las reglas convertidas en mapas del kernel
- [server/src/netperm/npdns.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npdns.c): los nombres desde el resolvedor del sistema
- [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c): reglas, precedencia y el lector estricto del archivo
- [server/src/ui/js_fw.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_fw.c): `lord.fw`, la API de la sesión
-- [apps/monitor/Firewall.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/Firewall.jsx): la sección de Ajustes
+- [apps/monitor/Firewall.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/Firewall.jsx) y [apps/monitor/FwRules.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/FwRules.jsx): las secciones de Ajustes
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c) y [server/src/sec/pwguard.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/pwguard.c): las restricciones en el broker y la guardia de PipeWire
- [server/tests/netperm_integration.sh](https://github.com/lordbasex/LordOS/blob/main/server/tests/netperm_integration.sh): la prueba con el kernel, 18 de 18
- [docs/FIREWALL.md](https://github.com/lordbasex/LordOS/blob/main/docs/FIREWALL.md) y [docs/MONITOR.md](https://github.com/lordbasex/LordOS/blob/main/docs/MONITOR.md)
diff --git a/web/content/features/visible-firewall.meta.json b/web/content/features/visible-firewall.meta.json
index 7a5f7b1..9281048 100644
--- a/web/content/features/visible-firewall.meta.json
+++ b/web/content/features/visible-firewall.meta.json
@@ -66,36 +66,36 @@
"id": "path",
"kind": "flow",
"title": {
- "en": "The path of a connection",
- "es": "El camino de una conexión",
- "pt": "O caminho de uma conexão"
+ "en": "The path of a connection or a device",
+ "es": "El camino de una conexión o un dispositivo",
+ "pt": "O caminho de uma conexão ou de um dispositivo"
},
"nodes": [
{
"id": "socket",
"label": {
- "en": "App opens a connection",
- "es": "La app abre una conexión",
- "pt": "O app abre uma conexão"
+ "en": "App opens a connection or a device",
+ "es": "La app abre una conexión o un dispositivo",
+ "pt": "O app abre uma conexão ou um dispositivo"
},
"sub": {
- "en": "connect, sendto, bind or socket",
- "es": "connect, sendto, bind o socket",
- "pt": "connect, sendto, bind ou socket"
+ "en": "connect, sendto, bind, socket, or open() of a device node",
+ "es": "connect, sendto, bind, socket u open() de un nodo de dispositivo",
+ "pt": "connect, sendto, bind, socket ou open() de um nó de dispositivo"
},
"tone": "user"
},
{
"id": "hook",
"label": {
- "en": "cgroup eBPF hook",
- "es": "Gancho eBPF de cgroup",
- "pt": "Gancho eBPF de cgroup"
+ "en": "eBPF programs in the kernel",
+ "es": "Programas eBPF en el kernel",
+ "pt": "Programas eBPF no kernel"
},
"sub": {
- "en": "In the kernel; finds the app by its scope",
- "es": "En el kernel; reconoce la app por su scope",
- "pt": "No kernel; reconhece o app pelo escopo"
+ "en": "cgroup network hooks; cgroup/dev for camera, USB, ALSA capture and /dev/fb; BPF LSM socket_create for Bluetooth. The app is found by its scope",
+ "es": "Ganchos de red de cgroup; cgroup/dev para cámara, USB, captura ALSA y /dev/fb; BPF LSM socket_create para Bluetooth. La app se reconoce por su scope",
+ "pt": "Ganchos de rede do cgroup; cgroup/dev para câmera, USB, captura ALSA e /dev/fb; BPF LSM socket_create para Bluetooth. O app é reconhecido pelo escopo"
},
"tone": "kernel"
},
@@ -107,9 +107,9 @@
"pt": "Regras por app"
},
"sub": {
- "en": "Restrictions, then the most specific rule, then trusted, then mode",
- "es": "Restricciones, luego la regla más específica, luego confianza, luego el modo",
- "pt": "Restrições, depois a regra mais específica, depois confiança, depois o modo"
+ "en": "Restrictions first, then the most specific rule, then trusted, then mode",
+ "es": "Primero las restricciones, luego la regla más específica, luego confianza, luego el modo",
+ "pt": "Primeiro as restrições, depois a regra mais específica, depois confiança, depois o modo"
},
"tone": "ours"
},
@@ -135,9 +135,9 @@
"pt": "Mapa do Monitor"
},
"sub": {
- "en": "New connections and counters, once per second",
- "es": "Conexiones nuevas y contadores, una vez por segundo",
- "pt": "Conexões novas e contadores, uma vez por segundo"
+ "en": "New connections, denials and counters, once per second",
+ "es": "Conexiones nuevas, rechazos y contadores, una vez por segundo",
+ "pt": "Conexões novas, negações e contadores, uma vez por segundo"
},
"tone": "ours"
}
@@ -181,9 +181,96 @@
}
],
"caption": {
- "en": "The decision happens in the kernel when the connection opens; nothing runs per packet.",
- "es": "La decisión ocurre en el kernel cuando se abre la conexión; nada corre por cada paquete.",
- "pt": "A decisão acontece no kernel quando a conexão abre; nada roda por pacote."
+ "en": "The decision happens in the kernel when a connection, a socket or a device opens; nothing runs per packet.",
+ "es": "La decisión ocurre en el kernel cuando se abre una conexión, un socket o un dispositivo; nada corre por cada paquete.",
+ "pt": "A decisão acontece no kernel quando abre uma conexão, um socket ou um dispositivo; nada roda por pacote."
+ }
+ },
+ {
+ "id": "restrictions",
+ "kind": "stack",
+ "title": {
+ "en": "Where each restriction is enforced",
+ "es": "Dónde se aplica cada restricción",
+ "pt": "Onde cada restrição é aplicada"
+ },
+ "nodes": [
+ {
+ "id": "broker",
+ "label": {
+ "en": "Broker in lord-server",
+ "es": "Broker en lord-server",
+ "pt": "Broker no lord-server"
+ },
+ "sub": {
+ "en": ".lpk apps and Passwords: all eight restrictions, refused without a prompt",
+ "es": "Apps .lpk y Contraseñas: las ocho restricciones, rechazadas sin aviso",
+ "pt": "Apps .lpk e Senhas: as oito restrições, recusadas sem aviso"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "launcher",
+ "label": {
+ "en": "App launcher",
+ "es": "Lanzador de apps",
+ "pt": "Lançador de apps"
+ },
+ "sub": {
+ "en": "Linux apps, no access to your files: own user, mount and PID namespaces, a tmpfs home and Landlock, from the next launch",
+ "es": "Apps de Linux, sin acceso a tus archivos: espacios de nombres de usuario, montaje y PID propios, un home en tmpfs y Landlock, desde el próximo inicio",
+ "pt": "Apps Linux, sem acesso aos seus arquivos: namespaces próprios de usuário, montagem e PID, uma home em tmpfs e Landlock, a partir da próxima abertura"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "notifyd",
+ "label": {
+ "en": "Notification server (notifyd)",
+ "es": "Servidor de notificaciones (notifyd)",
+ "pt": "Servidor de notificações (notifyd)"
+ },
+ "sub": {
+ "en": "Linux apps' notifications: the sender's identity comes from the bus; failures drop it",
+ "es": "Notificaciones de apps de Linux: la identidad del remitente la da el bus; si algo falla, se descarta",
+ "pt": "Notificações de apps Linux: a identidade do remetente vem do barramento; se algo falha, é descartada"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "pwguard",
+ "label": {
+ "en": "PipeWire guard (pwguard)",
+ "es": "Guardia de PipeWire (pwguard)",
+ "pt": "Guarda do PipeWire (pwguard)"
+ },
+ "sub": {
+ "en": "Microphone and camera through PipeWire: identity from the socket's credentials, applied live",
+ "es": "Micrófono y cámara por PipeWire: identidad tomada de las credenciales del socket, en vivo",
+ "pt": "Microfone e câmera pelo PipeWire: identidade tirada das credenciais do socket, ao vivo"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "kernel",
+ "label": {
+ "en": "lord-netperm's eBPF programs in the kernel",
+ "es": "Programas eBPF de lord-netperm en el kernel",
+ "pt": "Programas eBPF do lord-netperm no kernel"
+ },
+ "sub": {
+ "en": "Network hooks; cgroup/dev for camera, USB, ALSA capture and /dev/fb; BPF LSM socket_create for Bluetooth sockets",
+ "es": "Ganchos de red; cgroup/dev para cámara, USB, captura ALSA y /dev/fb; BPF LSM socket_create para sockets Bluetooth",
+ "pt": "Ganchos de rede; cgroup/dev para câmera, USB, captura ALSA e /dev/fb; BPF LSM socket_create para sockets Bluetooth"
+ },
+ "tone": "kernel"
+ }
+ ],
+ "edges": [],
+ "caption": {
+ "en": "Each restriction is checked where the resource is handed out, against the app's root-owned scope, never against a name the app gives itself.",
+ "es": "Cada restricción se revisa donde se entrega el recurso, contra el scope de la app, que es de root, nunca contra un nombre que la app se da a sí misma.",
+ "pt": "Cada restrição é conferida onde o recurso é entregue, contra o escopo do app, que é do root, nunca contra um nome que o app dá a si mesmo."
}
},
{
@@ -283,9 +370,9 @@
{
"path": "server/src/netperm/np.bpf.c",
"what": {
- "en": "The cgroup eBPF programs",
- "es": "Los programas eBPF de cgroup",
- "pt": "Os programas eBPF de cgroup"
+ "en": "The cgroup and LSM eBPF programs",
+ "es": "Los programas eBPF de cgroup y LSM",
+ "pt": "Os programas eBPF de cgroup e LSM"
}
},
{
@@ -328,6 +415,30 @@
"pt": "lord.fw, a API da sessão"
}
},
+ {
+ "path": "apps/monitor/FwRules.jsx",
+ "what": {
+ "en": "Network rules by app in Settings",
+ "es": "Reglas de red por app en Ajustes",
+ "pt": "Regras de rede por app nos Ajustes"
+ }
+ },
+ {
+ "path": "server/src/sec/restrict.c",
+ "what": {
+ "en": "Restrictions in the broker",
+ "es": "Restricciones en el broker",
+ "pt": "Restrições no broker"
+ }
+ },
+ {
+ "path": "server/src/sec/pwguard.c",
+ "what": {
+ "en": "The PipeWire guard",
+ "es": "La guardia de PipeWire",
+ "pt": "O guarda do PipeWire"
+ }
+ },
{
"path": "server/tests/netperm_integration.sh",
"what": {
diff --git a/web/content/features/visible-firewall.pt.md b/web/content/features/visible-firewall.pt.md
index 29077ea..7e1c052 100644
--- a/web/content/features/visible-firewall.pt.md
+++ b/web/content/features/visible-firewall.pt.md
@@ -14,7 +14,7 @@ Imagine um prédio com um porteiro na porta de cada apartamento, em vez de um s
- **Ajustes → Privacidade → Rede dos apps** tem um modo e duas listas:
- **Silencioso** (o padrão): o que não tem regra é permitido e fica anotado, para você revisar no Monitor. **Desligado**: só valem as suas negações explícitas e as restrições.
- **Apps confiáveis**: permitidos sem anotação. Uma negação explícita que você definiu continua valendo.
- - **Apps restritos**: marque o que um app não pode fazer. As restrições de rede são **Sem internet** (só LAN), **Sem LAN**, **Sem rede** nenhuma e **Sem conexões de entrada**.
+ - **Apps restritos**: marque o que um app não pode fazer. As restrições de rede são **Sem internet** (só LAN), **Sem LAN**, **Sem rede** nenhuma e **Sem conexões de entrada**. As outras tiram dispositivos e dados (veja [Além da rede](#alem-da-rede)).
[[shot:1]]
@@ -24,7 +24,7 @@ Imagine um prédio com um porteiro na porta de cada apartamento, em vez de um s
**1. Todo app tem um nome que o kernel enxerga.** Quando você abre um app Linux pelo lançador de apps, o `lord-server` pede ao root que o coloque num cgroup próprio, `app-lordos-<id>.scope`. Os apps `.lpk` instalados ganham `app-lordos-lpk-<id>.scope`. Esses escopos são criados pelo root e pertencem a ele, então um app não consegue se mudar para outro.
-**2. Um pequeno serviço root aplica as regras.** O `lord-netperm` carrega sete programas eBPF no cgroup do serviço do LordOS, que contém todas as sessões:
+**2. Um pequeno serviço root aplica as regras.** O `lord-netperm` carrega seus programas eBPF no cgroup do serviço do LordOS, que contém todas as sessões:
| Gancho do kernel | O que confere |
|---|---|
@@ -32,6 +32,8 @@ Imagine um prédio com um porteiro na porta de cada apartamento, em vez de um s
| `sendmsg4`, `sendmsg6` | UDP enviado com endereço |
| `bind4`, `bind6` | entrada: "sem conexões de entrada" e regras de entrada |
| `sock_create` | "sem rede": o app nem consegue criar um socket de internet |
+| `cgroup/dev` | os dispositivos de câmera, USB, captura ALSA e framebuffer de um app Linux, no `open()` |
+| LSM `socket_create` | os sockets Bluetooth de um app Linux |
Cada programa descobre a qual app pertence o processo que chamou (pelo ancestral do cgroup no nível do escopo, então processos filhos contam como o mesmo app), decide e devolve permitir ou negar. Um app negado recebe `EPERM`, "Operation not permitted".
@@ -49,7 +51,19 @@ O motor funciona, com cuidado sobre a origem dos nomes. Uma conexão só carrega
Na VM de teste, "negar tudo exceto example.com" deixou passar `https://example.com` e negou `https://www.debian.org`, 20 de 20 vezes, mesmo com o cache do resolvedor vazio. Um app que usa seu próprio DNS sobre HTTPS obtém endereços que o firewall nunca aprendeu, então, sob uma regra dessas, eles são negados.
-O que **ainda não** existe: uma tela para escrever regras por domínio. O motor de regras e a API `lord.fw.addRule` aceitam domínios, curingas, redes, portas e protocolos, mas a interface hoje oferece o botão por app e as listas de restrições. Botões por destino no Monitor estão planejados.
+**Onde escrevê-las.** Ajustes → Privacidade → **Regras de rede por app** mostra o padrão de cada app ("Permitir tudo" ou "Bloquear tudo exceto as regras") e suas regras na ordem em que vencem, já que vence a mais específica, com quando cada uma coincidiu pela última vez. A folha que adiciona uma regra aceita um domínio exato, `*.domínio`, um endereço ou uma rede, com porta e protocolo opcionais, e confere o que você digita enquanto digita. Em **Monitor → Rede**, "Permitir este domínio" ou "Bloquear este domínio" num destino de um app abre a mesma folha, preenchida com o nome que o resolvedor do sistema deu para aquele endereço.
+
+**A pegadinha, dita com honestidade: DNS criptografado.** Um navegador que resolve nomes por conta própria com DNS sobre HTTPS nunca pergunta ao resolvedor do sistema, então os nomes dele não são aprendidos. "Permitir só example.com" continua valendo (os endereços que ele obtém nunca foram aprendidos, então são bloqueados), mas "Bloquear example.com" não o impede. As regras por endereço e por rede, o padrão do app e suas restrições continuam valendo, e os Ajustes dizem isso abaixo das regras.
+
+## Além da rede
+
+A mesma lista de apps restritos também pode tirar a câmera, o microfone, a tela, o USB, os seus arquivos, a área de transferência, o Bluetooth e as notificações. Uma restrição vence as permissões que você deu antes: o app é recusado sem aviso, e restringir um app em execução tira dele a câmera e o microfone na hora. Cada uma é aplicada onde o recurso é entregue:
+
+[[diagram:restrictions]]
+
+- **Os apps isolados do LordOS** (apps `.lpk` e Senhas): as oito, no broker que já intermedeia tudo o que eles recebem.
+- **Os apps incluídos** (a linha "LordOS"): câmera, microfone, tela e notificações. Essa linha é o próprio desktop, então arquivos, USB, área de transferência e Bluetooth são restringidos por app.
+- **Os apps Linux abertos pelo lançador de apps:** os dispositivos de câmera, USB, captura ALSA e framebuffer são recusados no kernel (`cgroup/dev`); os sockets Bluetooth, por um programa BPF LSM; o microfone e as câmeras do PipeWire, pelo guarda do PipeWire do LordOS, ao vivo, identificando cada cliente pelas credenciais do seu socket; as notificações, pelo servidor de notificações do LordOS, que pergunta ao barramento quem está chamando e descarta a notificação se não conseguir saber; e "sem acesso aos seus arquivos" abre o app, a partir da próxima abertura, em namespaces próprios com uma pasta pessoal vazia e Landlock. A captura de tela nunca esteve ao alcance deles: não há protocolo de captura nem servidor X.
## As perguntas do leitor cético
@@ -61,7 +75,7 @@ O que **ainda não** existe: uma tela para escrever regras por domínio. O motor
**Posso permitir uma conexão só uma vez, ou ser perguntado?** O motor de regras conhece três durações (para sempre, até o app fechar, só uma vez) e um modo "perguntar", mas o aviso de pergunta ainda não foi construído: hoje "perguntar" se comporta como silencioso. Ele foi projetado como um aviso de nova tentativa: a primeira conexão é negada, você recebe *Permitir uma vez / Sempre / Negar*, e a nova tentativa do app passa.
-**O que acontece se o serviço parar?** Os vínculos dele são fechados e tudo fica permitido. O desktop não depende dele. Na ISO final, o serviço estava rodando com seus sete programas anexados.
+**O que acontece se o serviço parar?** Os vínculos dele são fechados e tudo fica permitido. O desktop não depende dele. Na ISO final, o serviço estava rodando com seus sete programas de rede anexados.
**O próprio serviço é perigoso?** Ele é mantido pequeno de propósito: não executa programas, não aceita argumentos, não tem sockets de internet próprios (sua unit só permite sockets Unix e de pacote) e aceita um único tipo de mensagem. Ele usa um carregador próprio sobre a chamada de sistema `bpf()`, com os programas compilados dentro do binário; sem libbpf nem bcc.
@@ -70,18 +84,20 @@ O que **ainda não** existe: uma tela para escrever regras por domínio. O motor
- **ICMP** (ping) só é bloqueado por "sem rede". **Conexões de entrada numa porta que já está aberta**, e `listen` sem `bind`, não são conferidas: isso exigiria um gancho por pacote.
- **A união do `user@` é grosseira:** enquanto um app restrito roda, todo processo no gerenciador systemd daquele usuário fica sujeito à união das restrições.
- **Um escopo recém-criado** é registrado em microssegundos, mas uma conexão feita antes disso passaria pelas regras padrão.
-- **Os nomes de host ainda não aparecem no Monitor**, só IPs e países. O Monitor nunca faz DNS reverso, então nenhum endereço sai da máquina só porque você olhou para ele.
-- **As restrições que não são de rede** (câmera, microfone, tela, USB, Bluetooth, arquivos, notificações) podem ser marcadas em Ajustes, mas **ainda não são aplicadas**: só as quatro restrições de rede são. Use as permissões por app para a câmera e o microfone.
-- **O arquivo de regras pode ser editado por apps Linux sem sandbox**, já que eles rodam como você. Os apps `.lpk` instalados não o alcançam.
+- **O Monitor lista os destinos como IPs e países;** o nome que o resolvedor do sistema deu aparece quando você abre "Permitir / Bloquear este domínio". O Monitor nunca faz DNS reverso, então nenhum endereço sai da máquina só porque você olhou para ele.
+- **As regras por domínio não veem apps que usam o próprio DNS criptografado** (veja acima).
+- **O que as restrições não cobrem para apps Linux:** o Bluetooth através do BlueZ no barramento do sistema (só os sockets Bluetooth diretos são recusados), o barramento do sistema em geral, a área de transferência e programas iniciados fora do lançador de apps. Um cliente novo de PipeWire de um app restrito tem alguns milissegundos antes de o guarda restringi-lo, e enquanto roda um app com a câmera ou o Bluetooth restritos, os seus próprios serviços de áudio também não conseguem abrir uma câmera nem um socket Bluetooth novos.
+- **O arquivo de regras pode ser editado por apps Linux sem sandbox**, já que eles rodam como você, a menos que estejam restritos com "sem acesso aos seus arquivos". Os apps `.lpk` instalados não o alcançam.
## Leia o código
-- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c): os sete programas eBPF de cgroup
+- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c): os programas eBPF de cgroup e LSM
- [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c): o serviço root
- [server/src/netperm/npcompile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npcompile.c): regras em mapas do kernel
- [server/src/netperm/npdns.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/npdns.c): nomes vindos do resolvedor do sistema
- [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c): regras, precedência e o leitor estrito do arquivo
- [server/src/ui/js_fw.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/js_fw.c): `lord.fw`, a API da sessão
-- [apps/monitor/Firewall.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/Firewall.jsx): a seção de Ajustes
+- [apps/monitor/Firewall.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/Firewall.jsx) e [apps/monitor/FwRules.jsx](https://github.com/lordbasex/LordOS/blob/main/apps/monitor/FwRules.jsx): as seções de Ajustes
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c) e [server/src/sec/pwguard.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/pwguard.c): as restrições no broker e o guarda do PipeWire
- [server/tests/netperm_integration.sh](https://github.com/lordbasex/LordOS/blob/main/server/tests/netperm_integration.sh): o teste com o kernel, 18 de 18
- [docs/FIREWALL.md](https://github.com/lordbasex/LordOS/blob/main/docs/FIREWALL.md) e [docs/MONITOR.md](https://github.com/lordbasex/LordOS/blob/main/docs/MONITOR.md)
diff --git a/web/content/paper/diagrams.json b/web/content/paper/diagrams.json
index ef6df7c..0c9ac1d 100644
--- a/web/content/paper/diagrams.json
+++ b/web/content/paper/diagrams.json
@@ -573,36 +573,36 @@
"id": "firewall",
"kind": "flow",
"title": {
- "en": "The path of a connection",
- "es": "El camino de una conexión",
- "pt": "O caminho de uma conexão"
+ "en": "The path of a connection or a device",
+ "es": "El camino de una conexión o un dispositivo",
+ "pt": "O caminho de uma conexão ou de um dispositivo"
},
"nodes": [
{
"id": "socket",
"label": {
- "en": "App opens a connection",
- "es": "La app abre una conexión",
- "pt": "O app abre uma conexão"
+ "en": "App opens a connection or a device",
+ "es": "La app abre una conexión o un dispositivo",
+ "pt": "O app abre uma conexão ou um dispositivo"
},
"sub": {
- "en": "connect, sendto, bind or socket",
- "es": "connect, sendto, bind o socket",
- "pt": "connect, sendto, bind ou socket"
+ "en": "connect, sendto, bind, socket, or open() of a device node",
+ "es": "connect, sendto, bind, socket u open() de un nodo de dispositivo",
+ "pt": "connect, sendto, bind, socket ou open() de um nó de dispositivo"
},
"tone": "user"
},
{
"id": "hook",
"label": {
- "en": "cgroup eBPF hook",
- "es": "Gancho eBPF de cgroup",
- "pt": "Gancho eBPF de cgroup"
+ "en": "eBPF programs in the kernel",
+ "es": "Programas eBPF en el kernel",
+ "pt": "Programas eBPF no kernel"
},
"sub": {
- "en": "In the kernel; finds the app by its scope",
- "es": "En el kernel; reconoce la app por su scope",
- "pt": "No kernel; reconhece o app pelo escopo"
+ "en": "cgroup network hooks; cgroup/dev for camera, USB, ALSA capture and /dev/fb; BPF LSM socket_create for Bluetooth. The app is found by its scope",
+ "es": "Ganchos de red de cgroup; cgroup/dev para cámara, USB, captura ALSA y /dev/fb; BPF LSM socket_create para Bluetooth. La app se reconoce por su scope",
+ "pt": "Ganchos de rede do cgroup; cgroup/dev para câmera, USB, captura ALSA e /dev/fb; BPF LSM socket_create para Bluetooth. O app é reconhecido pelo escopo"
},
"tone": "kernel"
},
@@ -614,9 +614,9 @@
"pt": "Regras por app"
},
"sub": {
- "en": "Restrictions, then the most specific rule, then trusted, then mode",
- "es": "Restricciones, luego la regla más específica, luego confianza, luego el modo",
- "pt": "Restrições, depois a regra mais específica, depois confiança, depois o modo"
+ "en": "Restrictions first, then the most specific rule, then trusted, then mode",
+ "es": "Primero las restricciones, luego la regla más específica, luego confianza, luego el modo",
+ "pt": "Primeiro as restrições, depois a regra mais específica, depois confiança, depois o modo"
},
"tone": "ours"
},
@@ -642,9 +642,9 @@
"pt": "Mapa do Monitor"
},
"sub": {
- "en": "New connections and counters, once per second",
- "es": "Conexiones nuevas y contadores, una vez por segundo",
- "pt": "Conexões novas e contadores, uma vez por segundo"
+ "en": "New connections, denials and counters, once per second",
+ "es": "Conexiones nuevas, rechazos y contadores, una vez por segundo",
+ "pt": "Conexões novas, negações e contadores, uma vez por segundo"
},
"tone": "ours"
}
@@ -688,9 +688,96 @@
}
],
"caption": {
- "en": "The decision happens in the kernel when the connection opens; nothing runs per packet.",
- "es": "La decisión ocurre en el kernel cuando se abre la conexión; nada corre por cada paquete.",
- "pt": "A decisão acontece no kernel quando a conexão abre; nada roda por pacote."
+ "en": "The decision happens in the kernel when a connection, a socket or a device opens; nothing runs per packet.",
+ "es": "La decisión ocurre en el kernel cuando se abre una conexión, un socket o un dispositivo; nada corre por cada paquete.",
+ "pt": "A decisão acontece no kernel quando abre uma conexão, um socket ou um dispositivo; nada roda por pacote."
+ }
+ },
+ {
+ "id": "restrictions",
+ "kind": "stack",
+ "title": {
+ "en": "Where each restriction is enforced",
+ "es": "Dónde se aplica cada restricción",
+ "pt": "Onde cada restrição é aplicada"
+ },
+ "nodes": [
+ {
+ "id": "broker",
+ "label": {
+ "en": "Broker in lord-server",
+ "es": "Broker en lord-server",
+ "pt": "Broker no lord-server"
+ },
+ "sub": {
+ "en": ".lpk apps and Passwords: all eight restrictions, refused without a prompt",
+ "es": "Apps .lpk y Contraseñas: las ocho restricciones, rechazadas sin aviso",
+ "pt": "Apps .lpk e Senhas: as oito restrições, recusadas sem aviso"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "launcher",
+ "label": {
+ "en": "App launcher",
+ "es": "Lanzador de apps",
+ "pt": "Lançador de apps"
+ },
+ "sub": {
+ "en": "Linux apps, no access to your files: own user, mount and PID namespaces, a tmpfs home and Landlock, from the next launch",
+ "es": "Apps de Linux, sin acceso a tus archivos: espacios de nombres de usuario, montaje y PID propios, un home en tmpfs y Landlock, desde el próximo inicio",
+ "pt": "Apps Linux, sem acesso aos seus arquivos: namespaces próprios de usuário, montagem e PID, uma home em tmpfs e Landlock, a partir da próxima abertura"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "notifyd",
+ "label": {
+ "en": "Notification server (notifyd)",
+ "es": "Servidor de notificaciones (notifyd)",
+ "pt": "Servidor de notificações (notifyd)"
+ },
+ "sub": {
+ "en": "Linux apps' notifications: the sender's identity comes from the bus; failures drop it",
+ "es": "Notificaciones de apps de Linux: la identidad del remitente la da el bus; si algo falla, se descarta",
+ "pt": "Notificações de apps Linux: a identidade do remetente vem do barramento; se algo falha, é descartada"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "pwguard",
+ "label": {
+ "en": "PipeWire guard (pwguard)",
+ "es": "Guardia de PipeWire (pwguard)",
+ "pt": "Guarda do PipeWire (pwguard)"
+ },
+ "sub": {
+ "en": "Microphone and camera through PipeWire: identity from the socket's credentials, applied live",
+ "es": "Micrófono y cámara por PipeWire: identidad tomada de las credenciales del socket, en vivo",
+ "pt": "Microfone e câmera pelo PipeWire: identidade tirada das credenciais do socket, ao vivo"
+ },
+ "tone": "ours"
+ },
+ {
+ "id": "kernel",
+ "label": {
+ "en": "lord-netperm's eBPF programs in the kernel",
+ "es": "Programas eBPF de lord-netperm en el kernel",
+ "pt": "Programas eBPF do lord-netperm no kernel"
+ },
+ "sub": {
+ "en": "Network hooks; cgroup/dev for camera, USB, ALSA capture and /dev/fb; BPF LSM socket_create for Bluetooth sockets",
+ "es": "Ganchos de red; cgroup/dev para cámara, USB, captura ALSA y /dev/fb; BPF LSM socket_create para sockets Bluetooth",
+ "pt": "Ganchos de rede; cgroup/dev para câmera, USB, captura ALSA e /dev/fb; BPF LSM socket_create para sockets Bluetooth"
+ },
+ "tone": "kernel"
+ }
+ ],
+ "edges": [],
+ "caption": {
+ "en": "Each restriction is checked where the resource is handed out, against the app's root-owned scope, never against a name the app gives itself.",
+ "es": "Cada restricción se revisa donde se entrega el recurso, contra el scope de la app, que es de root, nunca contra un nombre que la app se da a sí misma.",
+ "pt": "Cada restrição é conferida onde o recurso é entregue, contra o escopo do app, que é do root, nunca contra um nome que o app dá a si mesmo."
}
},
{
@@ -795,4 +882,4 @@
}
}
]
-}
\ No newline at end of file
+}
diff --git a/web/content/paper/meta.json b/web/content/paper/meta.json
index 4cead93..b205a17 100644
--- a/web/content/paper/meta.json
+++ b/web/content/paper/meta.json
@@ -9,7 +9,7 @@
"es": "Documento técnico: diseño, modelo de seguridad y estado actual",
"pt": "Documento técnico: projeto, modelo de segurança e estado atual"
},
- "version": "0.7.0 Beta",
+ "version": "0.8.0 Beta",
"date": "2026-10-18",
"authors": [
"Pablo Miranda",
diff --git a/web/content/paper/paper.en.md b/web/content/paper/paper.en.md
index 33943cf..7259b42 100644
--- a/web/content/paper/paper.en.md
+++ b/web/content/paper/paper.en.md
@@ -2,7 +2,7 @@
LordOS is a free GNU/Linux distribution based on Debian 13 that ships a desktop environment of its own, built from its fundamental components on top of Debian and Wayland. Instead of GNOME or KDE, it has its own display server and Wayland compositor written in C (`lord-server`), its own user-interface engine (React running on the QuickJS JavaScript engine, with layout, painting and text in native C code), its own native apps, and its own security services: an app sandbox launcher, a permission broker, a per-app permission store, a kernel-enforced per-app firewall, package signing and an encrypted password vault. It reuses what is mature and widely reviewed: the Linux kernel, Debian and its packages, Mesa, PipeWire, the Wayland protocol, and a handful of libraries (FFmpeg, Poppler, libarchive, OpenSSL, Monocypher) that are confined to small sandboxed helper processes.
-This paper describes the design and the current state of version **0.7.0 Beta** (October 2026) for a technical reader who wants to check the project rather than take it on trust. Every claim refers to a file in the public repository. Numbers are the ones measured in the project's test logs, and are labelled with where they were measured. Things that are designed but not built are marked as such.
+This paper describes the design and the current state of version **0.8.0 Beta** (October 2026), the first public release, for a technical reader who wants to check the project rather than take it on trust. Every claim refers to a file in the public repository. Numbers are the ones measured in the project's test logs, and are labelled with where they were measured. Things that are designed but not built are marked as such.
## 1. Vision
@@ -55,7 +55,7 @@ A running LordOS system has a small number of processes with clearly separated r
|---|---|---|
| `lord-sessiond` | root | login screen, sessions, lending the display and input to the visible session, remote desktop |
| `lord-netd` | root | the system network: DHCP, Wi-Fi, VPN; only the `net-*` actions |
-| `lord-netperm` | root (limited capabilities) | per-app network rules, enforced with cgroup eBPF |
+| `lord-netperm` | root (limited capabilities) | per-app network rules, and the device and Bluetooth restrictions of Linux apps, enforced with cgroup and LSM eBPF programs |
| `lord-fand` | root (no capabilities) | fan control by temperature |
| `lord-server` | the user | one per session: compositor, UI engine, broker |
| `lord-server --app <id>` | the user, sandboxed | one per running `.lpk` app (and Passwords) |
@@ -120,7 +120,7 @@ The compositor (`server/src/wl/wl.c`) uses only `libwayland-server` and code gen
Linux windows enter the SDK's window manager like any other, with title, focus, maximize, minimize and a Dock icon. Apps that ask for server-side decoration get the theme's frame; apps that draw their own (GTK 4) keep it, and their shadow is clipped. GTK 4 and libadwaita apps follow light/dark mode, the accent and the button order through an `org.freedesktop.portal.Settings` implementation that `lord-server` serves itself on the session bus; GTK 3 follows through the GSettings keyfile.
-**Xwayland is not supported**: LordOS doesn't run X11-only apps. Also pending: drag and drop, the primary selection, LordOS input methods inside Linux apps (`text-input`), activation (`xdg-activation`), explicit sync and SVG app icons. No screen-capture protocol is offered to apps.
+**Xwayland is not supported yet**: LordOS doesn't run X11-only apps (Xwayland is planned before 1.0, §10.3). Also pending: drag and drop, the primary selection, LordOS input methods inside Linux apps (`text-input`), activation (`xdg-activation`), explicit sync and SVG app icons. No screen-capture protocol is offered to apps.
### 3.5 Several displays and HiDPI
@@ -136,6 +136,7 @@ Every connected display is driven at once, extended or mirrored, in one logical
- **One session per user**, all able to live at once (fast user switching). Each is a `lord-server` that starts as root and drops privileges right away.
- **Display lending.** `lord-sessiond` opens the graphics card and the input devices as root and lends them to the session that is on the monitor, over a Unix socket. On a switch it revokes them: `EVIOCREVOKE` makes the old session's input file descriptors stop working, and `DROP_MASTER` takes display control away, before anything is given to the next session. The visible session keeps composing on the GPU without ever being root. A session off the monitor draws in memory, and only if someone is watching it remotely.
- **Locking really takes the session off the monitor**; it is not a layer drawn on top. If the user's session hangs, the login screen still works.
+- **Boot.** A LordOS GRUB theme draws the boot menu, and a LordOS Plymouth theme draws the splash (the crown with a progress bar). The hand-off has no black frame and no console text: Plymouth stops drawing and gives up display control while its last frame stays on screen, `lord-sessiond` takes display control and sets the first real frame of the login screen, and only then does Plymouth quit, keeping the splash on screen until it is replaced.
**Remote desktop.** The same service offers the desktop to a browser on the local network at `https://<address>:5673` (5673 spells "LORD" on a phone keypad). It is **off by default** and is turned on in Settings → Sharing. It uses TLS 1.2 or later with a self-signed P-256 certificate whose fingerprint Settings shows for comparison, a strict content security policy, same-origin checks, per-IP waits on failed logins, and a session cookie that is `Secure`, `HttpOnly` and `SameSite=Strict`. The login page never lists user accounts. The process that serves a connection drops root as soon as it knows whose session it is. Screen updates are sent as PNG when still and JPEG while moving. Audio is designed but not built. Internet access is not intended; a VPN is recommended.
@@ -145,6 +146,7 @@ Every connected display is driven at once, extended or mirrored, in one logical
- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c), [server/src/tp](https://github.com/lordbasex/LordOS/tree/main/server/src/tp), [server/src/ui/grab.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/grab.c)
- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c), [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c)
- [server/src/remote/sessiond.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sessiond.c), [server/src/remote/monitor.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/monitor.c), [server/src/remote/sess.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sess.c)
+- [tools/boot/plymouth](https://github.com/lordbasex/LordOS/tree/main/tools/boot/plymouth), [tools/iso/grub](https://github.com/lordbasex/LordOS/tree/main/tools/iso/grub), [docs/SESSIONS.md](https://github.com/lordbasex/LordOS/blob/main/docs/SESSIONS.md)
## 4. The UI engine
@@ -204,7 +206,7 @@ The Store shows Debian's apps by category with search, `.lpk` apps and local `.d
### 5.4 Linux apps
-Linux apps with a `.desktop` file appear in the app launcher. Launching goes through `lord.apps.launch(id)`: the interface can only name an installed `.desktop` file; `lord-server` re-reads it, checks it, builds `argv` from its `Exec` line by the specification and runs it with `execve`, without a shell or caller arguments, inside its own root-owned cgroup scope. Chromium and Firefox are preinstalled in the ISO and were verified with the LordOS frame. **Linux apps are not sandboxed by LordOS**; they get attribution and the per-app firewall (§6.6).
+Linux apps with a `.desktop` file appear in the app launcher. Launching goes through `lord.apps.launch(id)`: the interface can only name an installed `.desktop` file; `lord-server` re-reads it, checks it, builds `argv` from its `Exec` line by the specification and runs it with `execve`, without a shell or caller arguments, inside its own root-owned cgroup scope. Chromium and Firefox are preinstalled in the ISO and were verified with the LordOS frame. **Linux apps are not sandboxed by default**: they run as the user, as on any Debian system. They get attribution, the per-app firewall and the per-app restrictions the owner sets (§6.6), including an optional "no access to your files" view applied by the launcher.
### 5.5 WebAssembly
@@ -214,7 +216,7 @@ LordOS includes its own WebAssembly interpreter in C (`server/src/wasm`), expose
- **Live ISO** for 64-bit PCs, with a graphical installer (UEFI and BIOS).
- **Raspberry Pi 5 image** for SD card or NVMe (§7.4).
-- **On an existing Debian 13**: `curl -fsSL https://lordos.org/install.sh | sh`. The script asks before changing anything, downloads `SHA256SUMS` and verifies its Ed25519 signature with the release key embedded in the script, refuses to continue without a valid signature, checks the `.deb`'s SHA-256, installs it with apt and sets the system up like the ISO. The repository is private until the first public beta, so the download path is not public yet.
+- **On an existing Debian 13**: `curl -fsSL https://lordos.org/install.sh | sh`. The script asks before changing anything, downloads `SHA256SUMS` and verifies its Ed25519 signature with the release key embedded in the script, refuses to continue without a valid signature, checks the `.deb`'s SHA-256, installs it with apt and sets the system up like the ISO. The release files are published on GitHub Releases.
### Source files
@@ -235,7 +237,7 @@ LordOS is designed against these threats:
- **An attacker on the local network** trying to use the remote desktop or to tamper with downloads.
- **Tampered packages and releases.**
-Outside the model, for now: a compromised kernel or root account; physical attacks; side channels; and Linux apps reading the user's files (they run as the user, as on any Debian system). Linux apps are confined only on the network.
+Outside the model, for now: a compromised kernel or root account; physical attacks; side channels; and Linux apps that the owner hasn't restricted, which run as the user, as on any Debian system, and can read the user's files. Linux apps are confined only by the restrictions the owner sets for them (§6.6), and only when they are started from the app launcher.
### 6.2 Least privilege
@@ -255,7 +257,18 @@ Outside the model, for now: a compromised kernel or root account; physical attac
| `lord-netperm` | `RELOAD` with no data | run programs; take arguments; open internet sockets |
| `lord-fand` | `STATUS` for anyone; `PROFILE`, `CURVE`, `FORCE` for administrators | name paths or devices; run programs; use the network |
-### 6.4 The app sandbox
+### 6.4 What is isolated, and the app sandbox
+
+Not every program on LordOS is sandboxed. This is exactly what applies to each kind:
+
+| Kind | Process | Sandbox | cgroup scope | Broker and permissions | Firewall and restrictions (§6.6) |
+|---|---|---|---|---|---|
+| `.lpk` apps and Passwords | own (`lord-server --app <id>`) | Landlock, seccomp, no capabilities | own, root-owned, with limits | every call checked in C | network rules and all eight non-network restrictions, in the broker |
+| Other built-in apps | inside `lord-server` | no (they are part of the desktop) | `lord-server`'s | no broker; camera, microphone and screen are checked in C | as "LordOS": network rules; camera, microphone, screen and notifications |
+| Linux apps from the app launcher | own | none by default; with "no access to your files", their own user, mount and PID namespaces plus Landlock, from the next launch | own, root-owned | no | network rules; camera, microphone, USB, Bluetooth sockets, files and notifications; not the clipboard |
+| Terminal programs | children of the Terminal's shell | no | `lord-server`'s | no | as "LordOS": network rules |
+
+A program started some other way, outside the app launcher, is in no app scope and gets no per-app rules. Flatpak and bubblewrap are not used.
Each `.lpk` app, and the Passwords app, runs as `lord-server --app <id>`: the same binary in "app mode", launched by `lord-server` with a validated package id as its only argument. The process connects to the compositor as a Wayland client and opens the broker socket, then applies the sandbox, and only then loads the app's code (`server/src/sec/sandbox.c`):
@@ -280,21 +293,54 @@ The isolated app talks to `lord-server` only over one `SOCK_SEQPACKET` socket. E
- **Revocation:** denying the camera or the microphone in Settings stops it at once (the app's `lord-media` is killed; the PipeWire stream is closed). The `network` permission is decided at launch.
- **Keyring:** an isolated app's keyring requests carry an owner that `lord-server` sets from the verified app id.
-**Limits.** There is no "allow once". Some declared permissions (Bluetooth, launching apps, notifications) have no broker call yet, so isolated apps can't use those capabilities at all; listening on a port is governed by the network permission. A Linux app running as the user could edit the permissions file.
+**Restrictions beat permissions.** A firewall restriction (§6.6) wins over any stored decision: the request is refused without a prompt, even if the app was allowed before, and restricting a running app takes its camera and microphone away at once, like revoking.
+
+**Limits.** There is no "allow once". Some declared permissions (Bluetooth, launching apps, notifications) have no broker call yet, so isolated apps can't use those capabilities at all; listening on a port is governed by the network permission. A Linux app running as the user could edit the permissions file, unless it is restricted with "no access to your files".
-### 6.6 The per-app firewall and the Monitor
+### 6.6 The per-app firewall, its restrictions and the Monitor
[[diagram:firewall]]
-`lord-netperm` enforces per-app network rules in the kernel. Linux apps opened from the app launcher run in `app-lordos-<id>.scope`, `.lpk` apps in `app-lordos-lpk-<id>.scope`, and the rest of the session counts as `lordos`. All scopes are root-owned. The service loads seven cgroup eBPF programs (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`) into the cgroup of `lordos.service`, finds each process's app by its cgroup ancestor, and returns allow or deny (`EPERM`). The programs are compiled into the binary and loaded with LordOS's own loader over the `bpf()` system call; libbpf and bcc are not used.
+`lord-netperm` enforces per-app rules in the kernel. Linux apps opened from the app launcher run in `app-lordos-<id>.scope`, `.lpk` apps in `app-lordos-lpk-<id>.scope`, and the rest of the session counts as `lordos`. All scopes are root-owned. The service loads seven network programs (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`), a device program (`cgroup/dev`) and a per-cgroup LSM program on `socket_create` into the cgroup of `lordos.service`, finds each process's app by its cgroup ancestor, and returns allow or deny (`EPERM`). The programs are compiled into the binary and loaded with LordOS's own loader over the `bpf()` system call, which also reads the kernel's BTF to find the LSM hook; libbpf and bcc are not used. If the kernel refuses the device or the LSM program, the network programs still work and the service says so.
- **Rules** support exact domains, wildcards, IPv4/IPv6 networks, `lan`, `internet`, ports, protocols and direction. Restrictions (no internet, no LAN, no network, no incoming) come first; then the most specific rule wins, with deny beating allow at equal specificity; then trusted apps; then the mode (silent, the default, or off). `npcompile.c` precomputes this into hash and longest-prefix-match maps. A test runs the kernel's decision code against the reference decision maker over 480,000 random connections: 0 differences.
-- **Domain names** come only from the system resolver: systemd-resolved's monitor interface or, without it, replies from port 53 of the configured servers read by a receive-only packet socket. Answers an app received on its own sockets are never trusted.
+- **Domain names** come only from the system resolver: systemd-resolved's monitor interface or, without it, replies from port 53 of the configured servers read by a receive-only packet socket. Answers an app received on its own sockets are never trusted. So an app that resolves names itself with encrypted DNS (DNS over HTTPS inside a browser, for example) isn't matched by domain rules: an "allow only example.com" rule still blocks it, but a "block example.com" rule doesn't stop it. Address and network rules, the app's default and its restrictions still apply, and Settings says so under the rules.
+- **Rules in the interface.** Settings → Privacy → Network rules by app shows each app's default ("allow all" or "block all except rules") and its rules in the order they win, with when each one last matched; the sheet that adds a rule checks what is typed as it is typed. In Monitor → Network, "Allow / Block this domain" on one of an app's destinations opens the same sheet, prefilled with the name the system resolver gave for that address.
- **Escapes.** The cgroup tree is root-owned, so an app can't move itself. A process that asks the user's systemd manager for a new unit (`systemd-run --user`) lands under `user@<uid>.service`; `lord-netperm` attaches the same programs there and holds such processes to the strictest union of that user's running restricted apps. Tested: all escape attempts denied, other users unaffected.
- **Cost**: about 0.5 µs per UDP connect, TCP within noise, no change in throughput, since nothing runs per packet.
-- **The Monitor** shows each app's connections (from `sock_diag`), bytes, destinations by country from a local database, and a per-app Rule switch. No address ever leaves the machine for lookups: no reverse DNS, no online geolocation.
+- **The Monitor** shows each app's connections (from `sock_diag`) and the destinations the firewall reported recently, bytes, destinations by country from a local database, and a per-app Rule switch. No address ever leaves the machine for lookups: no reverse DNS, no online geolocation.
+
+**Restrictions beyond the network.** Besides the four network restrictions (no internet, no LAN, no network, no incoming connections), the owner can restrict an app from the camera, the microphone, the screen, USB, files, the clipboard, Bluetooth and notifications. Each one is enforced where the resource is handed out, checked against the app's scope and never against a name the app gives itself, and it beats any permission granted in `permisos.json`.
+
+[[diagram:restrictions]]
+
+| Restriction | `.lpk` apps and Passwords | Built-in apps ("LordOS") | Linux apps from the app launcher |
+|---|---|---|---|
+| camera | broker (`brokercam.c`) | `js_media.c` | `cgroup/dev` on V4L2 nodes, and the PipeWire guard |
+| microphone | broker | `js_media.c` | the PipeWire guard, and `cgroup/dev` on ALSA capture nodes |
+| screen | broker (no capture API in app mode) | `js_media.c` | by design: no capture protocol, no X server, no screen-cast portal; `/dev/fb*` denied |
+| USB | broker (the security key of Passwords) | not offered | `cgroup/dev`: raw USB, hidraw and USB serial nodes |
+| files | broker (file picker, camera saves) | not offered | the launcher: own namespaces, a tmpfs home and Landlock, from the next launch |
+| clipboard | broker | not offered | not available |
+| Bluetooth | broker (no Bluetooth API in app mode) | not offered | BPF LSM program on `socket_create`: no `AF_BLUETOOTH` sockets |
+| notifications | the `notifications` permission | `sdk/notify.js` | `notifyd`, by the caller's verified identity |
+
+For isolated apps the broker (`sec/restrict.c`) is the single enforcement point: a restricted request is refused without a prompt, and restricting a running app takes its camera and microphone away at once (`tests/broker_restrict_test.c` covers every restriction, with and without it). The "LordOS" row is the desktop itself (Files, copy and paste, Disks, Bluetooth settings), so it doesn't offer files, USB, clipboard or Bluetooth; individual apps are restricted instead. For Linux apps:
-**Limits.** "Ask" mode is designed but behaves as silent today. There is no interface yet for domain rules or per-destination switches (the engine and the API support them). ICMP is blocked only by "no network"; connections to an already-open port aren't checked. Settings also offers non-network restrictions (camera, microphone, screen, USB, Bluetooth, files, notifications): they are stored, but **no component enforces them yet**.
+- **Devices.** In cgroup v2 the device controller is a BPF program. `lord-netperm`'s refuses `open()` and `mknod()` of the device classes the app is restricted from (V4L2, raw USB, hidraw, USB serial, ALSA capture nodes, `/dev/fb*`) and allows everything else. It applies to the next `open`; a descriptor already open stays usable.
+- **Bluetooth sockets.** The inet socket hook never sees `AF_BLUETOOTH`, so a per-cgroup LSM program on `socket_create` refuses them.
+- **Files.** Right before `execve`, the launcher's child enters its own unprivileged user, mount and PID namespaces. The home folder is an empty tmpfs holding only the app's own folders (derived from its desktop id, never from fields a `.desktop` file controls) and the file it was opened with; the runtime folder holds only the Wayland and sound sockets, so the session bus and the user's systemd are out of reach; then Landlock limits the rest. It applies at the next launch. GTK apps, Firefox and Chromium run without their D-Bus integrations.
+- **Notifications.** `notifyd` asks the bus for the caller's PID (only an answer the bus itself sent counts), finds its app scope, and drops the notification of a restricted app; an error or a late answer drops it too (fail closed).
+- **Microphone and camera through PipeWire.** The PipeWire guard (`sec/pwguard.c`), `lord-server`'s own PipeWire client, identifies each client by the PID PipeWire took from the socket's credentials and, for a restricted app, hides capture nodes and destroys its capture streams within a second, a recording already running included. While a restricted app runs, a client whose identity can't be established is treated as restricted.
+
+**Limits.** "Ask" mode is designed but behaves as silent today. ICMP is blocked only by "no network"; connections to an already-open port aren't checked. The restrictions for Linux apps don't cover:
+
+- BlueZ over D-Bus: a Bluetooth-restricted app can still ask `bluetoothd` on the system bus to scan, pair and connect;
+- the system bus, which stays reachable even with "no access to your files";
+- the clipboard;
+- apps started outside the app launcher, which are in no app scope;
+- side effects of the `user@` union: while a restricted app runs, the user's own services are held to the same union (a headset's call audio, which PipeWire opens per call, stops for that time);
+- a window of a few milliseconds in which a new PipeWire client of a restricted app has full permissions, or in which a capture stream can receive audio before it is destroyed.
### 6.7 Helpers that process untrusted data
@@ -312,7 +358,7 @@ The isolated app talks to `lord-server` only over one `SOCK_SEQPACKET` socket. E
`.lpk` packages carry a manifest of every file's SHA-256 and an Ed25519 signature over it. SHA-256 and Ed25519 are LordOS's own code (Ed25519 following TweetNaCl's arithmetic), tested against NIST and RFC 8032 vectors (55 of 55). Verification happens in C at install and at load. The Store shows the trust level: **LordOS** (official key, compiled into the binary so no file can add one), **Verified author** (listed in the signed catalog), **Signed by <name>**, or **Unsigned** with a warning. Updates must be signed with the same key. A signed catalog carries a revocation list. If you edit an installed app, LordOS marks it "Modified by you", can restore the original, or can share your version signed with your own key, with credit to the original.
-**Status:** official packages are signed today with a development key; the final key replaces it for the public release. A signed LordOS app repository for the Store is not built yet.
+**Status:** in 0.8.0 Beta, official packages are still signed with a development key, until the final key replaces it. A signed LordOS app repository for the Store is not built yet.
### 6.9 Release signing
@@ -320,7 +366,7 @@ Every release file (the `.deb`, the ISO and the Raspberry Pi image) is listed wi
`c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
-The private key lives only on the maintainer's machine, never in the repository or on a build machine. §11 shows how to check a download.
+The private key lives only on the maintainer's machine, never in the repository or on a build machine. Each release also carries an SPDX 2.3 software bill of materials (SBOM) per architecture, listed in `SHA256SUMS` and so covered by the signature, and its release notes come from `CHANGELOG.md`, kept in the Keep a Changelog format. §11 shows how to check a download.
### 6.10 The vault
@@ -330,13 +376,19 @@ The private key lives only on the maintainer's machine, never in the repository
A window marked protected (Passwords is) is painted black in every path that copies pixels out: screenshots, recordings, thumbnails, the remote desktop, and Wayland menus and fullscreen. The real monitor shows it normally. Linux apps have no screen-capture protocol to begin with.
+### 6.12 Disclosure and standards
+
+Vulnerabilities are reported as described in `SECURITY.md`, which is also published as `/.well-known/security.txt` (RFC 9116). LordOS's processes are **aligned with, not certified against**, ISO/IEC 29147 and ISO/IEC 30111 (vulnerability disclosure and handling), ISO/IEC 5230 (OpenChain license compliance: the inventory in `THIRD_PARTY.md`, the license notices and the SBOM) and ISO/IEC 18974 (OpenChain security assurance: the SBOM plus Debian's security updates for the packages LordOS depends on). lordos.org publishes the legal and trust pages (security policy, code signing, licenses, privacy, support lifecycle, standards) and says what is still missing: no formal self-certification, no automated matching of the SBOM against vulnerability databases, no SBOM for the whole images, and no third-party audit.
+
### Source files
- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c), [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c), [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c), [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c)
- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c), [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c), [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c)
-- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh)
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c), [server/src/sec/pwguard.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/pwguard.c), [server/src/hw/notifyd.c](https://github.com/lordbasex/LordOS/blob/main/server/src/hw/notifyd.c), [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c), [server/tests/broker_restrict_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/broker_restrict_test.c)
+- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh), [tools/release/make-sbom.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/make-sbom.sh)
- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c), [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c)
- [server/src/media/capture.c](https://github.com/lordbasex/LordOS/blob/main/server/src/media/capture.c)
+- [SECURITY.md](https://github.com/lordbasex/LordOS/blob/main/SECURITY.md), [docs/COMPLIANCE.md](https://github.com/lordbasex/LordOS/blob/main/docs/COMPLIANCE.md), [CHANGELOG.md](https://github.com/lordbasex/LordOS/blob/main/CHANGELOG.md)
## 7. Performance
@@ -396,7 +448,7 @@ There are no measurements on real PCs in the repository yet. The ISO is tested o
## 8. Visual experience
- **A design guide.** Apps follow a shared guide (`docs/DESIGN.md`): an 8 px spacing grid, a small type scale, consistent control heights and one accent-coloured action per view. The tokens are exported by the SDK (`spacing`, `typeScale`, `controlSize`), and every app went through documented before-and-after polish passes in light, dark, right-to-left and small windows.
-- **Themes.** A theme is a complete desktop written in React: menu bar, Dock, app launcher, Control Center and window frame, plus its tokens. LordOS ships a default theme with a menu bar and a Dock, and a Classic theme with a taskbar and a start menu. Themes switch live; settings persist.
+- **Themes.** A theme is a complete desktop written in React: menu bar, Dock, app launcher, Control Center and window frame, plus its tokens. LordOS ships a default theme with a menu bar and a Dock, and a Classic theme with a taskbar and a start menu, which today is a template and becomes a second full appearance before 1.0 (§10.3). Themes switch live; settings persist.
- **Light and dark, accents.** Both modes and the accent colour apply live to native apps, isolated apps and, through the portal and GSettings, GTK apps.
- **Right to left.** The whole interface mirrors for Arabic, Hebrew and similar scripts, including isolated apps, which follow the session's language live.
- **Lumo.** LordOS's mascot is Lumo, a small celestial fox, used in welcome screens, empty states and brand material, with a fixed set of poses defined in the brand guide.
@@ -424,14 +476,16 @@ There are no measurements on real PCs in the repository yet. The ISO is tested o
### 10.1 Where things stand
-Milestones M1 to M9 are complete in 0.7.0 Beta: the display server, the UI engine, the SDK and themes, the terminal, languages and complex scripts, Linux app compatibility, packages and system services, sessions, isolation and the firewall, and the M9 app suites (documents and printing, media, system apps, passwords, hardware settings, mail and calendar). The final ISO was built and tested on virtual machines on 18 October 2026.
+0.8.0 Beta is the first public release; 0.7.0 was an internal build and was never published. Milestones M1 to M9 are complete: the display server, the UI engine, the SDK and themes, the terminal, languages and complex scripts, Linux app compatibility, packages and system services, sessions, isolation and the firewall, and the M9 app suites (documents and printing, media, system apps, passwords, hardware settings, mail and calendar). Before the release, the firewall's non-network restrictions became enforced for every kind of app, domain rules got an interface in Settings and the Monitor, the boot got a LordOS splash and GRUB theme, and releases gained a signed SBOM and a changelog. The final ISO was built and tested on virtual machines on 18 October 2026.
### 10.2 Known limitations
- Real hardware: AMD and Nvidia GPUs, real monitors, laptops (battery, backlight, lid), Bluetooth controllers, printers and scanners, FIDO2 keys and real mail providers are untested.
-- The Raspberry Pi 5 hasn't been tested with a monitor, and its built image hasn't been booted yet.
-- Linux apps are not sandboxed; no Xwayland.
-- Firewall: no ask mode, no domain-rule interface, non-network restrictions not enforced.
+- The Raspberry Pi 5 is the only supported board, with LordOS's build of its kernel with Landlock; it hasn't been tested with a monitor, and its built image hasn't been booted yet.
+- Linux apps are not sandboxed by default; no Xwayland yet.
+- Firewall: no ask mode; domain rules don't see apps that resolve names with their own encrypted DNS.
+- Restrictions for Linux apps don't cover BlueZ over D-Bus, the system bus, the clipboard or apps started outside the app launcher; the `user@` union also holds the user's own services while a restricted app runs; a new PipeWire client has a window of a few milliseconds before the guard restricts it (§6.6).
+- The `.lpk` signing key is still a development key, and there is no signed LordOS app repository yet.
- Permissions: no "allow once"; camera and microphone use by Linux apps isn't shown.
- Secure Boot must be turned off; signing with a shim is pending.
- Package downloads use HTTP (signed and hashed).
@@ -440,7 +494,12 @@ Milestones M1 to M9 are complete in 0.7.0 Beta: the display server, the UI engin
### 10.3 Next
-Before the final release: the final ISO with everything and a Raspberry Pi 5 image tested on the real board. After it, as planned in `docs/ROADMAP.md`: a desktop virtualization app built on KVM and QEMU; an Android container with LineageOS and apps from LordOS's Store; the firewall's ask mode; accessibility; and a full demo video.
+Next, a Raspberry Pi 5 image booted and tested on the real board. Before 1.0, as planned in `docs/ROADMAP.md`:
+
+- **Xwayland**, started on demand, with the compositor as the X window manager and X11 apps getting the same per-app identity, firewall and restrictions as Wayland apps;
+- **the Classic theme as a second full appearance**: taskbar, start menu with search, tray, quick settings, notification panel and window snapping, with the same apps in a different skin, built only from LordOS's own design and assets.
+
+After 1.0: a desktop virtualization app built on KVM and QEMU; an Android container with LineageOS and apps from LordOS's Store; the firewall's ask mode; accessibility; and a full demo video.
### Source files
@@ -486,16 +545,18 @@ openssl pkeyutl -verify -pubin -inkey lordos-release.pub.pem -rawin -in SHA256SU
sha256sum -c --ignore-missing SHA256SUMS
```
+The SBOM of each architecture (`lordos_<version>_<arch>.spdx.json`) is listed in `SHA256SUMS` too, so the same check covers it.
+
### 11.4 Check a running system
-- `systemctl status lord-netperm lord-fand lordos` shows the services; the ISO test confirmed seven BPF programs attached.
+- `systemctl status lord-netperm lord-fand lordos` shows the services; the ISO test confirmed the seven network programs attached. If the kernel refuses the device or the LSM program, `lord-netperm` reports `"devices":false` or `"bluetooth":false`.
- `cat /proc/<pid>/status | grep -E 'Seccomp|NoNewPrivs'` on a `lord-server --app` process shows the sandbox.
- `systemd-cgls` shows the root-owned `lordos-session-<uid>` tree with one scope per app.
- Remote desktop: `ss -ltn` shows nothing on port 5673 until you enable it in Settings → Sharing.
## 12. License and credits
-LordOS's code is released under the **MIT license**. Third-party components keep their own licenses, listed in `THIRD_PARTY.md`: QuickJS and stb (vendored), Monocypher (CC0/BSD-2), the EFF word list (CC BY 3.0 US), the common-password list (MIT), DB-IP Lite country data (CC BY 4.0), Natural Earth (public domain), and the Inter, JetBrains Mono and Plus Jakarta Sans fonts (OFL).
+LordOS's code is released under the **MIT license**. Third-party components keep their own licenses, listed in `THIRD_PARTY.md`: QuickJS and stb (vendored), Monocypher (CC0/BSD-2), the EFF word list (CC BY 3.0 US), the common-password list (MIT), DB-IP Lite country data (CC BY 4.0), Natural Earth (public domain), and the Inter, JetBrains Mono and Plus Jakarta Sans fonts (OFL). Each release carries an SPDX SBOM of what the package bundles and depends on (`docs/COMPLIANCE.md`).
LordOS is created by the **IPERFEX** group: **Pablo Miranda** and **Federico Pereira**.
@@ -505,14 +566,18 @@ LordOS is created by the **IPERFEX** group: **Pablo Miranda** and **Federico Per
- **cgroup (v2):** a kernel mechanism that groups processes to account for and limit resources. LordOS gives each app its own group, a "scope", and uses it to identify the app in the firewall.
- **Compositor:** the program that combines the windows of all apps into the final image on screen.
- **DRM/KMS:** the kernel interfaces for graphics devices and for setting display modes.
-- **eBPF:** small verified programs that run inside the kernel; LordOS attaches them to cgroups to decide network connections.
+- **eBPF:** small verified programs that run inside the kernel; LordOS attaches them to cgroups to decide network connections, device opens and Bluetooth sockets.
- **evdev:** the kernel interface for input devices.
+- **LSM (BPF LSM):** the kernel's security hooks; with the `bpf` LSM, a small program attached per cgroup can refuse an operation, such as creating a Bluetooth socket.
+- **Namespace:** a kernel feature that gives a process its own view of something (users, mounts, process ids); LordOS uses unprivileged ones for Linux apps restricted from the user's files.
- **Helper:** a small LordOS process that handles untrusted data or secrets in a stricter sandbox (`lord-doc`, `lord-media`, `lord-maild`, `lord-vault`).
- **Landlock:** a kernel feature that lets an unprivileged process restrict which files and network ports it, and its children, may use.
- **`.lpk`:** LordOS's package format for installable native apps.
- **`.lvault`:** LordOS's encrypted vault file format.
+- **PipeWire guard:** `lord-server`'s own PipeWire client that hides capture devices from restricted Linux apps and stops their capture streams.
- **Powerbox:** a file dialog drawn by the system that hands the app only the file the user chose.
- **QuickJS:** a small JavaScript engine written in C.
+- **SBOM:** a software bill of materials, the machine-readable list of the components a release contains, in the SPDX format.
- **Scope:** a cgroup for one app, such as `app-lordos-lpk-<id>.scope`.
- **seccomp-bpf:** a kernel filter that restricts which system calls a process may make.
- **Secret Service:** the freedesktop D-Bus standard Linux apps use to store secrets.
@@ -527,8 +592,8 @@ LordOS is created by the **IPERFEX** group: **Pablo Miranda** and **Federico Per
| 3. Compositor | GPU.md, DISPLAYS.md, WINDOWS.md, TRACKPAD.md, WAYLAND.md, SESSIONS.md, REMOTE.md |
| 4. UI engine | ARCHITECTURE.md, LANGUAGES.md, TERMINAL.md |
| 5. Applications | NATIVE-APPS.md, PACKAGES.md, WASM.md, FILES.md, MEDIA.md, DOCUMENTS.md, MAIL.md, ISO.md, INSTALL-DEBIAN.md |
-| 6. Security | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md |
+| 6. Security | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md, COMPLIANCE.md, and `SECURITY.md` |
| 7. Performance | ISO.md, RASPBERRY.md, FANS.md, DISPLAYS.md, GPU.md |
| 8. Visual experience | DESIGN.md, LORDOS-BRAND.md, LANGUAGES.md, DOCK.md |
| 9. Extensibility | NATIVE-APPS.md, WASM.md, and `apps/README.md`, `themes/README.md` |
-| 10. Roadmap | ROADMAP.md and `CHANGELOG.md` |
+| 10. Roadmap | ROADMAP.md, RELEASING.md and `CHANGELOG.md` |
diff --git a/web/content/paper/paper.es.md b/web/content/paper/paper.es.md
index d672412..a067ea5 100644
--- a/web/content/paper/paper.es.md
+++ b/web/content/paper/paper.es.md
@@ -2,7 +2,7 @@
LordOS es una distribución GNU/Linux libre basada en Debian 13 que trae un entorno de escritorio propio, construido desde sus componentes fundamentales sobre Debian y Wayland. En lugar de GNOME o KDE, tiene su propio servidor gráfico y compositor Wayland escritos en C (`lord-server`), su propio motor de interfaz (React corriendo sobre el motor de JavaScript QuickJS, con layout, pintado y texto en código C nativo), sus propias apps nativas y sus propios servicios de seguridad: un lanzador de apps en caja de arena, un broker de permisos, un registro de permisos por app, un firewall por app que aplica el kernel, firma de paquetes y una bóveda de contraseñas cifrada. Reutiliza lo que está maduro y muy revisado: el kernel Linux, Debian y sus paquetes, Mesa, PipeWire, el protocolo Wayland y unas pocas bibliotecas (FFmpeg, Poppler, libarchive, OpenSSL, Monocypher) que quedan encerradas en pequeños procesos ayudantes aislados.
-Este documento describe el diseño y el estado actual de la versión **0.7.0 Beta** (octubre de 2026) para un lector técnico que quiere verificar el proyecto en lugar de creer en él a ciegas. Cada afirmación remite a un archivo del repositorio público. Los números son los medidos en los registros de prueba del proyecto, e indican dónde se midieron. Lo que está diseñado pero no construido aparece marcado como tal.
+Este documento describe el diseño y el estado actual de la versión **0.8.0 Beta** (octubre de 2026), el primer lanzamiento público, para un lector técnico que quiere verificar el proyecto en lugar de creer en él a ciegas. Cada afirmación remite a un archivo del repositorio público. Los números son los medidos en los registros de prueba del proyecto, e indican dónde se midieron. Lo que está diseñado pero no construido aparece marcado como tal.
## 1. Visión
@@ -55,7 +55,7 @@ Un LordOS en marcha tiene pocos procesos, con roles bien separados:
|---|---|---|
| `lord-sessiond` | root | pantalla de inicio de sesión, sesiones, prestar la pantalla y la entrada a la sesión visible, escritorio remoto |
| `lord-netd` | root | la red del sistema: DHCP, Wi-Fi, VPN; solo las acciones `net-*` |
-| `lord-netperm` | root (capacidades limitadas) | reglas de red por app, aplicadas con eBPF de cgroup |
+| `lord-netperm` | root (capacidades limitadas) | reglas de red por app, y las restricciones de dispositivos y Bluetooth de las apps de Linux, aplicadas con programas eBPF de cgroup y de LSM |
| `lord-fand` | root (sin capacidades) | control de ventiladores según la temperatura |
| `lord-server` | el usuario | uno por sesión: compositor, motor de interfaz, broker |
| `lord-server --app <id>` | el usuario, aislado | uno por app `.lpk` en ejecución (y Contraseñas) |
@@ -120,7 +120,7 @@ El compositor (`server/src/wl/wl.c`) usa solo `libwayland-server` y código gene
Las ventanas de Linux entran al gestor de ventanas del SDK como cualquier otra, con título, foco, maximizar, minimizar e ícono en el Dock. Las apps que piden decoración del lado del servidor reciben el marco del tema; las que dibujan el suyo (GTK 4) lo conservan, y se recorta su sombra. Las apps GTK 4 y libadwaita siguen el modo claro u oscuro, el color de acento y el orden de los botones a través de una implementación de `org.freedesktop.portal.Settings` que `lord-server` sirve él mismo en el bus de sesión; GTK 3 los sigue a través del archivo de claves de GSettings.
-**Xwayland no está soportado**: LordOS no corre apps que solo hablan X11. También quedan pendientes: arrastrar y soltar, la selección primaria, los métodos de entrada de LordOS dentro de apps de Linux (`text-input`), la activación (`xdg-activation`), la sincronización explícita y los íconos de app en SVG. No se ofrece a las apps ningún protocolo de captura de pantalla.
+**Xwayland todavía no está soportado**: LordOS no corre apps que solo hablan X11 (Xwayland está planeado antes de la 1.0, §10.3). También quedan pendientes: arrastrar y soltar, la selección primaria, los métodos de entrada de LordOS dentro de apps de Linux (`text-input`), la activación (`xdg-activation`), la sincronización explícita y los íconos de app en SVG. No se ofrece a las apps ningún protocolo de captura de pantalla.
### 3.5 Varias pantallas y HiDPI
@@ -136,6 +136,7 @@ Todas las pantallas conectadas se manejan a la vez, extendidas o en espejo, en u
- **Una sesión por usuario**, y todas pueden vivir a la vez (cambio rápido de usuario). Cada una es un `lord-server` que arranca como root y suelta los privilegios enseguida.
- **Préstamo de la pantalla.** `lord-sessiond` abre la placa gráfica y los dispositivos de entrada como root y se los presta a la sesión que está en el monitor, por un socket Unix. Al cambiar, los revoca: `EVIOCREVOKE` hace que los descriptores de entrada de la sesión anterior dejen de funcionar, y `DROP_MASTER` le quita el control de la pantalla, antes de darle algo a la sesión siguiente. La sesión visible sigue componiendo en la GPU sin ser nunca root. Una sesión fuera del monitor dibuja en memoria, y solo si alguien la está mirando de forma remota.
- **Bloquear saca de verdad la sesión del monitor**; no es una capa dibujada encima. Si la sesión del usuario se cuelga, la pantalla de inicio sigue funcionando.
+- **Arranque.** Un tema de GRUB de LordOS dibuja el menú de arranque, y un tema de Plymouth de LordOS dibuja la pantalla de carga (la corona con una barra de progreso). El traspaso no tiene ningún cuadro negro ni texto de consola: Plymouth deja de dibujar y suelta el control de la pantalla mientras su último cuadro queda visible, `lord-sessiond` toma el control de la pantalla y pone el primer cuadro real de la pantalla de inicio de sesión, y recién entonces Plymouth termina, dejando la pantalla de carga hasta que se reemplaza.
**Escritorio remoto.** El mismo servicio ofrece el escritorio a un navegador de la red local en `https://<dirección>:5673` (5673 deletrea "LORD" en un teclado de teléfono). Viene **desactivado por defecto** y se activa en Ajustes → Compartir. Usa TLS 1.2 o superior con un certificado P-256 autofirmado cuya huella muestra Ajustes para comparar, una política de seguridad de contenido estricta, controles de mismo origen, esperas por IP ante inicios fallidos y una cookie de sesión `Secure`, `HttpOnly` y `SameSite=Strict`. La página de inicio nunca lista las cuentas de usuario. El proceso que atiende una conexión suelta root apenas sabe de quién es la sesión. Las actualizaciones de pantalla se envían como PNG cuando está quieta y como JPEG mientras se mueve. El audio está diseñado pero no construido. El acceso desde internet no está previsto; se recomienda una VPN.
@@ -145,6 +146,7 @@ Todas las pantallas conectadas se manejan a la vez, extendidas o en espejo, en u
- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c), [server/src/tp](https://github.com/lordbasex/LordOS/tree/main/server/src/tp), [server/src/ui/grab.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/grab.c)
- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c), [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c)
- [server/src/remote/sessiond.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sessiond.c), [server/src/remote/monitor.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/monitor.c), [server/src/remote/sess.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sess.c)
+- [tools/boot/plymouth](https://github.com/lordbasex/LordOS/tree/main/tools/boot/plymouth), [tools/iso/grub](https://github.com/lordbasex/LordOS/tree/main/tools/iso/grub), [docs/SESSIONS.md](https://github.com/lordbasex/LordOS/blob/main/docs/SESSIONS.md)
## 4. El motor de interfaz
@@ -204,7 +206,7 @@ La Tienda muestra las apps de Debian por categoría con búsqueda, las apps `.lp
### 5.4 Apps de Linux
-Las apps de Linux con un archivo `.desktop` aparecen en el lanzador de apps. El lanzamiento pasa por `lord.apps.launch(id)`: la interfaz solo puede nombrar un archivo `.desktop` instalado; `lord-server` lo vuelve a leer, lo verifica, arma `argv` a partir de su línea `Exec` según la especificación y lo ejecuta con `execve`, sin shell ni argumentos del llamador, dentro de su propio scope de cgroup que pertenece a root. Chromium y Firefox vienen preinstalados en la ISO y se verificaron con el marco de LordOS. **LordOS no aísla las apps de Linux**; tienen atribución y el firewall por app (§6.6).
+Las apps de Linux con un archivo `.desktop` aparecen en el lanzador de apps. El lanzamiento pasa por `lord.apps.launch(id)`: la interfaz solo puede nombrar un archivo `.desktop` instalado; `lord-server` lo vuelve a leer, lo verifica, arma `argv` a partir de su línea `Exec` según la especificación y lo ejecuta con `execve`, sin shell ni argumentos del llamador, dentro de su propio scope de cgroup que pertenece a root. Chromium y Firefox vienen preinstalados en la ISO y se verificaron con el marco de LordOS. **LordOS no aísla las apps de Linux de forma predeterminada**: corren como el usuario, como en cualquier Debian. Tienen atribución, el firewall por app y las restricciones por app que fije el dueño (§6.6), incluida una vista opcional "sin acceso a tus archivos" que aplica el lanzador.
### 5.5 WebAssembly
@@ -214,7 +216,7 @@ LordOS incluye su propio intérprete de WebAssembly en C (`server/src/wasm`), ex
- **ISO live** para PC de 64 bits, con un instalador gráfico (UEFI y BIOS).
- **Imagen para Raspberry Pi 5** para tarjeta SD o NVMe (§7.4).
-- **Sobre un Debian 13 existente**: `curl -fsSL https://lordos.org/install.sh | sh`. El script pregunta antes de cambiar nada, descarga `SHA256SUMS` y verifica su firma Ed25519 con la clave de releases embebida en el script, se niega a seguir sin una firma válida, verifica el SHA-256 del `.deb`, lo instala con apt y configura el sistema como la ISO. El repositorio es privado hasta la primera beta pública, así que la ruta de descarga todavía no es pública.
+- **Sobre un Debian 13 existente**: `curl -fsSL https://lordos.org/install.sh | sh`. El script pregunta antes de cambiar nada, descarga `SHA256SUMS` y verifica su firma Ed25519 con la clave de releases embebida en el script, se niega a seguir sin una firma válida, verifica el SHA-256 del `.deb`, lo instala con apt y configura el sistema como la ISO. Los archivos del release se publican en GitHub Releases.
### Archivos fuente
@@ -235,7 +237,7 @@ LordOS está diseñado contra estas amenazas:
- **Un atacante en la red local** que intenta usar el escritorio remoto o alterar descargas.
- **Paquetes y releases alterados.**
-Fuera del modelo, por ahora: un kernel o una cuenta root comprometidos; ataques físicos; canales laterales; y apps de Linux que leen los archivos del usuario (corren como el usuario, como en cualquier Debian). A las apps de Linux se las limita solo en la red.
+Fuera del modelo, por ahora: un kernel o una cuenta root comprometidos; ataques físicos; canales laterales; y apps de Linux que el dueño no restringió, que corren como el usuario, como en cualquier Debian, y pueden leer sus archivos. A las apps de Linux se las limita solo con las restricciones que el dueño les fija (§6.6), y solo cuando se abren desde el lanzador de apps.
### 6.2 Mínimo privilegio
@@ -255,7 +257,18 @@ Fuera del modelo, por ahora: un kernel o una cuenta root comprometidos; ataques
| `lord-netperm` | `RELOAD` sin datos | ejecutar programas; recibir argumentos; abrir sockets de internet |
| `lord-fand` | `STATUS` para cualquiera; `PROFILE`, `CURVE`, `FORCE` para administradores | nombrar rutas o dispositivos; ejecutar programas; usar la red |
-### 6.4 La caja de arena de las apps
+### 6.4 Qué está aislado, y la caja de arena de las apps
+
+No todos los programas de LordOS están aislados. Esto es exactamente lo que se aplica a cada tipo:
+
+| Tipo | Proceso | Caja de arena | Scope de cgroup | Broker y permisos | Firewall y restricciones (§6.6) |
+|---|---|---|---|---|---|
+| Apps `.lpk` y Contraseñas | propio (`lord-server --app <id>`) | Landlock, seccomp, sin capacidades | propio, de root, con límites | cada llamada se verifica en C | reglas de red y las ocho restricciones que no son de red, en el broker |
+| Las demás apps incluidas | dentro de `lord-server` | no (son parte del escritorio) | el de `lord-server` | sin broker; cámara, micrófono y pantalla se verifican en C | como "LordOS": reglas de red; cámara, micrófono, pantalla y notificaciones |
+| Apps de Linux desde el lanzador de apps | propio | ninguna de forma predeterminada; con "sin acceso a tus archivos", espacios de nombres de usuario, montaje y PID propios más Landlock, desde el próximo inicio | propio, de root | no | reglas de red; cámara, micrófono, USB, sockets Bluetooth, archivos y notificaciones; no el portapapeles |
+| Programas de la Terminal | hijos de la shell de la Terminal | no | el de `lord-server` | no | como "LordOS": reglas de red |
+
+Un programa iniciado de otra forma, fuera del lanzador de apps, no está en ningún scope de app y no recibe reglas por app. No se usan Flatpak ni bubblewrap.
Cada app `.lpk`, y la app Contraseñas, corre como `lord-server --app <id>`: el mismo binario en "modo app", lanzado por `lord-server` con un id de paquete validado como único argumento. El proceso se conecta al compositor como cliente Wayland y abre el socket del broker, después aplica la caja de arena, y recién entonces carga el código de la app (`server/src/sec/sandbox.c`):
@@ -280,21 +293,54 @@ La app aislada habla con `lord-server` solo por un socket `SOCK_SEQPACKET`. Cada
- **Revocación:** denegar la cámara o el micrófono en Ajustes los corta al instante (se mata el `lord-media` de la app; se cierra el stream de PipeWire). El permiso `network` se decide al lanzar la app.
- **Llavero:** los pedidos al llavero de una app aislada llevan un dueño que `lord-server` fija a partir del id verificado de la app.
-**Límites.** No hay "permitir una vez". Algunos permisos declarables (Bluetooth, lanzar apps, notificaciones) todavía no tienen llamada en el broker, así que las apps aisladas directamente no pueden usar esas capacidades; escuchar en un puerto depende del permiso de red. Una app de Linux que corre como el usuario podría editar el archivo de permisos.
+**Las restricciones les ganan a los permisos.** Una restricción del firewall (§6.6) gana sobre cualquier decisión guardada: el pedido se rechaza sin aviso, aunque la app haya tenido permiso antes, y restringir una app en marcha le quita la cámara y el micrófono al instante, como revocar.
+
+**Límites.** No hay "permitir una vez". Algunos permisos declarables (Bluetooth, lanzar apps, notificaciones) todavía no tienen llamada en el broker, así que las apps aisladas directamente no pueden usar esas capacidades; escuchar en un puerto depende del permiso de red. Una app de Linux que corre como el usuario podría editar el archivo de permisos, salvo que esté restringida con "sin acceso a tus archivos".
-### 6.6 El firewall por app y el Monitor
+### 6.6 El firewall por app, sus restricciones y el Monitor
[[diagram:firewall]]
-`lord-netperm` aplica las reglas de red por app en el kernel. Las apps de Linux abiertas desde el lanzador de apps corren en `app-lordos-<id>.scope`, las apps `.lpk` en `app-lordos-lpk-<id>.scope`, y el resto de la sesión cuenta como `lordos`. Todos los scopes pertenecen a root. El servicio carga siete programas eBPF de cgroup (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`) en el cgroup de `lordos.service`, identifica la app de cada proceso por su ancestro de cgroup y devuelve permitir o denegar (`EPERM`). Los programas están compilados dentro del binario y se cargan con un cargador propio de LordOS sobre la llamada al sistema `bpf()`; no se usan libbpf ni bcc.
+`lord-netperm` aplica las reglas por app en el kernel. Las apps de Linux abiertas desde el lanzador de apps corren en `app-lordos-<id>.scope`, las apps `.lpk` en `app-lordos-lpk-<id>.scope`, y el resto de la sesión cuenta como `lordos`. Todos los scopes pertenecen a root. El servicio carga siete programas de red (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`), un programa de dispositivos (`cgroup/dev`) y un programa LSM por cgroup sobre `socket_create` en el cgroup de `lordos.service`, identifica la app de cada proceso por su ancestro de cgroup y devuelve permitir o denegar (`EPERM`). Los programas están compilados dentro del binario y se cargan con un cargador propio de LordOS sobre la llamada al sistema `bpf()`, que además lee el BTF del kernel para encontrar el gancho LSM; no se usan libbpf ni bcc. Si el kernel rechaza el programa de dispositivos o el LSM, los programas de red siguen funcionando y el servicio lo avisa.
- **Las reglas** admiten dominios exactos, comodines, redes IPv4/IPv6, `lan`, `internet`, puertos, protocolos y dirección. Primero van las restricciones (sin internet, sin LAN, sin red, sin entrantes); después gana la regla más específica, y denegar le gana a permitir a igual especificidad; después las apps de confianza; después el modo (silencioso, el predeterminado, o apagado). `npcompile.c` precalcula todo esto en mapas hash y de coincidencia por prefijo más largo. Una prueba corre el código de decisión del kernel contra el decisor de referencia sobre 480.000 conexiones aleatorias: 0 diferencias.
-- **Los nombres de dominio** vienen solo del resolvedor del sistema: la interfaz de monitoreo de systemd-resolved o, sin él, las respuestas del puerto 53 de los servidores configurados, leídas por un socket de paquetes que solo recibe. Nunca se confía en respuestas que una app recibió por sus propios sockets.
+- **Los nombres de dominio** vienen solo del resolvedor del sistema: la interfaz de monitoreo de systemd-resolved o, sin él, las respuestas del puerto 53 de los servidores configurados, leídas por un socket de paquetes que solo recibe. Nunca se confía en respuestas que una app recibió por sus propios sockets. Por eso, una app que resuelve nombres por su cuenta con DNS cifrado (DNS sobre HTTPS dentro de un navegador, por ejemplo) no queda alcanzada por las reglas de dominio: una regla "permitir solo example.com" la sigue bloqueando, pero una regla "bloquear example.com" no la frena. Las reglas por dirección y por red, el valor predeterminado de la app y sus restricciones siguen valiendo, y Ajustes lo dice debajo de las reglas.
+- **Las reglas en la interfaz.** Ajustes → Privacidad → Reglas de red por app muestra el valor predeterminado de cada app ("Permitir todo" o "Bloquear todo salvo las reglas") y sus reglas en el orden en que ganan, con cuándo coincidió cada una por última vez; la hoja para agregar una regla revisa lo que se escribe mientras se escribe. En Monitor → Red, "Permitir / Bloquear este dominio" sobre un destino de una app abre la misma hoja, completada con el nombre que dio el resolvedor del sistema para esa dirección.
- **Escapes.** El árbol de cgroups pertenece a root, así que una app no puede moverse sola. Un proceso que le pide al gestor de systemd del usuario una unidad nueva (`systemd-run --user`) termina bajo `user@<uid>.service`; `lord-netperm` engancha los mismos programas ahí y somete esos procesos a la unión más estricta de las apps restringidas en ejecución de ese usuario. Probado: todos los intentos de escape denegados, los otros usuarios sin afectar.
- **Costo**: alrededor de 0,5 µs por connect de UDP, TCP dentro del ruido, sin cambio en el rendimiento, porque nada corre por paquete.
-- **El Monitor** muestra las conexiones de cada app (desde `sock_diag`), los bytes, los destinos por país desde una base de datos local y un interruptor de Regla por app. Ninguna dirección sale de la máquina para consultas: sin DNS inverso, sin geolocalización en línea.
+- **El Monitor** muestra las conexiones de cada app (desde `sock_diag`) y los destinos que el firewall informó hace poco, los bytes, los destinos por país desde una base de datos local y un interruptor de Regla por app. Ninguna dirección sale de la máquina para consultas: sin DNS inverso, sin geolocalización en línea.
+
+**Restricciones más allá de la red.** Además de las cuatro restricciones de red (sin internet, sin LAN, sin red, sin conexiones entrantes), el dueño puede restringirle a una app la cámara, el micrófono, la pantalla, el USB, los archivos, el portapapeles, el Bluetooth y las notificaciones. Cada una se aplica donde se entrega el recurso, se verifica contra el scope de la app y nunca contra un nombre que la app se da a sí misma, y gana sobre cualquier permiso otorgado en `permisos.json`.
+
+[[diagram:restrictions]]
+
+| Restricción | Apps `.lpk` y Contraseñas | Apps incluidas ("LordOS") | Apps de Linux desde el lanzador de apps |
+|---|---|---|---|
+| cámara | broker (`brokercam.c`) | `js_media.c` | `cgroup/dev` sobre los nodos V4L2, y la guardia de PipeWire |
+| micrófono | broker | `js_media.c` | la guardia de PipeWire, y `cgroup/dev` sobre los nodos de captura ALSA |
+| pantalla | broker (sin API de captura en modo app) | `js_media.c` | por diseño: sin protocolo de captura, sin servidor X, sin portal de captura de pantalla; `/dev/fb*` denegado |
+| USB | broker (la llave de seguridad de Contraseñas) | no se ofrece | `cgroup/dev`: nodos USB directos, hidraw y serie USB |
+| archivos | broker (selector de archivos, guardados de la cámara) | no se ofrece | el lanzador: espacios de nombres propios, un home en tmpfs y Landlock, desde el próximo inicio |
+| portapapeles | broker | no se ofrece | no disponible |
+| Bluetooth | broker (sin API de Bluetooth en modo app) | no se ofrece | programa BPF LSM sobre `socket_create`: sin sockets `AF_BLUETOOTH` |
+| notificaciones | el permiso `notifications` | `sdk/notify.js` | `notifyd`, por la identidad verificada de quien llama |
+
+Para las apps aisladas, el broker (`sec/restrict.c`) es el único punto de aplicación: un pedido restringido se rechaza sin aviso, y restringir una app en marcha le quita la cámara y el micrófono al instante (`tests/broker_restrict_test.c` cubre cada restricción, con y sin ella). La fila "LordOS" es el escritorio mismo (Archivos, copiar y pegar, Discos, los ajustes de Bluetooth), así que no ofrece archivos, USB, portapapeles ni Bluetooth; en su lugar se restringen apps individuales. Para las apps de Linux:
-**Límites.** El modo "preguntar" está diseñado pero hoy se comporta como silencioso. Todavía no hay interfaz para reglas por dominio ni interruptores por destino (el motor y la API las soportan). ICMP se bloquea solo con "sin red"; las conexiones a un puerto ya abierto no se verifican. Ajustes también ofrece restricciones que no son de red (cámara, micrófono, pantalla, USB, Bluetooth, archivos, notificaciones): se guardan, pero **ningún componente las aplica todavía**.
+- **Dispositivos.** En cgroup v2 el controlador de dispositivos es un programa BPF. El de `lord-netperm` rechaza `open()` y `mknod()` de las clases de dispositivo que la app tiene restringidas (V4L2, USB directo, hidraw, serie USB, nodos de captura ALSA, `/dev/fb*`) y permite todo lo demás. Se aplica en el próximo `open`; un descriptor ya abierto sigue sirviendo.
+- **Sockets Bluetooth.** El gancho de sockets inet nunca ve `AF_BLUETOOTH`, así que un programa LSM por cgroup sobre `socket_create` los rechaza.
+- **Archivos.** Justo antes de `execve`, el hijo del lanzador entra en sus propios espacios de nombres de usuario, montaje y PID, sin privilegios. La carpeta personal es un tmpfs vacío que tiene solo las carpetas propias de la app (derivadas de su id de escritorio, nunca de campos que controla un archivo `.desktop`) y el archivo con el que se abrió; la carpeta de runtime tiene solo los sockets de Wayland y de sonido, así que el bus de sesión y el systemd del usuario quedan fuera de alcance; después Landlock limita el resto. Se aplica desde el próximo inicio. Las apps GTK, Firefox y Chromium corren sin sus integraciones de D-Bus.
+- **Notificaciones.** `notifyd` le pide al bus el PID de quien llama (solo cuenta una respuesta que mandó el propio bus), encuentra su scope de app y descarta la notificación de una app restringida; un error o una respuesta tardía también la descartan (falla cerrado).
+- **Micrófono y cámara por PipeWire.** La guardia de PipeWire (`sec/pwguard.c`), el cliente de PipeWire propio de `lord-server`, identifica a cada cliente por el PID que PipeWire tomó de las credenciales del socket y, para una app restringida, oculta los nodos de captura y destruye sus streams de captura en menos de un segundo, incluida una grabación ya en curso. Mientras corre una app restringida, un cliente cuya identidad no se puede establecer se trata como restringido.
+
+**Límites.** El modo "preguntar" está diseñado pero hoy se comporta como silencioso. ICMP se bloquea solo con "sin red"; las conexiones a un puerto ya abierto no se verifican. Las restricciones para apps de Linux no cubren:
+
+- BlueZ por D-Bus: una app con el Bluetooth restringido todavía puede pedirle a `bluetoothd`, por el bus del sistema, que busque, empareje y conecte;
+- el bus del sistema, que sigue al alcance incluso con "sin acceso a tus archivos";
+- el portapapeles;
+- las apps iniciadas fuera del lanzador de apps, que no están en ningún scope de app;
+- los efectos secundarios de la unión de `user@`: mientras corre una app restringida, los servicios propios del usuario quedan sujetos a la misma unión (el audio de llamadas de unos auriculares, que PipeWire abre en cada llamada, se corta durante ese tiempo);
+- una ventana de pocos milisegundos en la que un cliente nuevo de PipeWire de una app restringida tiene todos los permisos, o en la que un stream de captura puede recibir audio antes de ser destruido.
### 6.7 Ayudantes que procesan datos no confiables
@@ -312,7 +358,7 @@ La app aislada habla con `lord-server` solo por un socket `SOCK_SEQPACKET`. Cada
Los paquetes `.lpk` llevan un manifiesto con el SHA-256 de cada archivo y una firma Ed25519 sobre él. SHA-256 y Ed25519 son código propio de LordOS (Ed25519 siguiendo la aritmética de TweetNaCl), probado contra los vectores del NIST y del RFC 8032 (55 de 55). La verificación ocurre en C al instalar y al cargar. La Tienda muestra el nivel de confianza: **LordOS** (clave oficial, compilada dentro del binario para que ningún archivo pueda agregar otra), **Autor verificado** (listado en el catálogo firmado), **Firmado por <nombre>**, o **Sin firmar** con una advertencia. Las actualizaciones tienen que estar firmadas con la misma clave. Un catálogo firmado lleva una lista de revocación. Si editás una app instalada, LordOS la marca "Modificada por vos", puede restaurar la original o compartir tu versión firmada con tu propia clave, con crédito al original.
-**Estado:** hoy los paquetes oficiales se firman con una clave de desarrollo; la clave final la reemplaza para el lanzamiento público. Todavía no está construido un repositorio firmado de apps de LordOS para la Tienda.
+**Estado:** en la 0.8.0 Beta los paquetes oficiales todavía se firman con una clave de desarrollo, hasta que la reemplace la clave final. Todavía no está construido un repositorio firmado de apps de LordOS para la Tienda.
### 6.9 Firma de releases
@@ -320,7 +366,7 @@ Cada archivo de release (el `.deb`, la ISO y la imagen para Raspberry Pi) aparec
`c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
-La clave privada vive solo en la máquina del mantenedor, nunca en el repositorio ni en una máquina de compilación. La §11 muestra cómo verificar una descarga.
+La clave privada vive solo en la máquina del mantenedor, nunca en el repositorio ni en una máquina de compilación. Cada release trae además una lista de materiales de software (SBOM) SPDX 2.3 por arquitectura, listada en `SHA256SUMS` y por lo tanto cubierta por la firma, y sus notas salen de `CHANGELOG.md`, escrito en el formato Keep a Changelog. La §11 muestra cómo verificar una descarga.
### 6.10 La bóveda
@@ -330,13 +376,19 @@ La clave privada vive solo en la máquina del mantenedor, nunca en el repositori
Una ventana marcada como protegida (Contraseñas lo está) se pinta en negro en todos los caminos que copian píxeles hacia afuera: capturas, grabaciones, miniaturas, el escritorio remoto, y los menús y la pantalla completa de Wayland. El monitor real la muestra normalmente. Las apps de Linux, para empezar, no tienen ningún protocolo de captura de pantalla.
+### 6.12 Divulgación y estándares
+
+Las vulnerabilidades se informan como describe `SECURITY.md`, que también se publica como `/.well-known/security.txt` (RFC 9116). Los procesos de LordOS están **alineados con, no certificados en**, ISO/IEC 29147 e ISO/IEC 30111 (divulgación y manejo de vulnerabilidades), ISO/IEC 5230 (cumplimiento de licencias de OpenChain: el inventario en `THIRD_PARTY.md`, los avisos de licencia y el SBOM) e ISO/IEC 18974 (garantía de seguridad de OpenChain: el SBOM más las actualizaciones de seguridad de Debian para los paquetes de los que depende LordOS). lordos.org publica las páginas legales y de confianza (política de seguridad, firma de código, licencias, privacidad, ciclo de soporte, estándares) y dice lo que todavía falta: sin autocertificación formal, sin cruce automático del SBOM con bases de vulnerabilidades, sin SBOM de las imágenes completas y sin auditoría de terceros.
+
### Archivos fuente
- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c), [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c), [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c), [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c)
- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c), [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c), [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c)
-- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh)
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c), [server/src/sec/pwguard.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/pwguard.c), [server/src/hw/notifyd.c](https://github.com/lordbasex/LordOS/blob/main/server/src/hw/notifyd.c), [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c), [server/tests/broker_restrict_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/broker_restrict_test.c)
+- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh), [tools/release/make-sbom.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/make-sbom.sh)
- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c), [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c)
- [server/src/media/capture.c](https://github.com/lordbasex/LordOS/blob/main/server/src/media/capture.c)
+- [SECURITY.md](https://github.com/lordbasex/LordOS/blob/main/SECURITY.md), [docs/COMPLIANCE.md](https://github.com/lordbasex/LordOS/blob/main/docs/COMPLIANCE.md), [CHANGELOG.md](https://github.com/lordbasex/LordOS/blob/main/CHANGELOG.md)
## 7. Rendimiento
@@ -396,7 +448,7 @@ Todavía no hay mediciones en PC reales en el repositorio. La ISO se prueba en m
## 8. Experiencia visual
- **Una guía de diseño.** Las apps siguen una guía común (`docs/DESIGN.md`): una grilla de espaciado de 8 px, una escala tipográfica chica, alturas de controles consistentes y una sola acción con el color de acento por vista. El SDK exporta los tokens (`spacing`, `typeScale`, `controlSize`), y cada app pasó por rondas de pulido documentadas con capturas de antes y después en claro, oscuro, de derecha a izquierda y en ventanas chicas.
-- **Temas.** Un tema es un escritorio completo escrito en React: barra de menú, Dock, lanzador de apps, Centro de control y marco de ventana, más sus tokens. LordOS trae un tema predeterminado con barra de menú y Dock, y un tema Clásico con barra de tareas y menú de inicio. Los temas cambian en vivo; la configuración se conserva.
+- **Temas.** Un tema es un escritorio completo escrito en React: barra de menú, Dock, lanzador de apps, Centro de control y marco de ventana, más sus tokens. LordOS trae un tema predeterminado con barra de menú y Dock, y un tema Clásico con barra de tareas y menú de inicio, que hoy es una plantilla y pasa a ser una segunda apariencia completa antes de la 1.0 (§10.3). Los temas cambian en vivo; la configuración se conserva.
- **Claro y oscuro, acentos.** Los dos modos y el color de acento se aplican en vivo a las apps nativas, a las apps aisladas y, a través del portal y de GSettings, a las apps GTK.
- **De derecha a izquierda.** Toda la interfaz se espeja para el árabe, el hebreo y escrituras similares, incluidas las apps aisladas, que siguen en vivo el idioma de la sesión.
- **Lumo.** La mascota de LordOS es Lumo, un pequeño zorro celestial, que aparece en pantallas de bienvenida, estados vacíos y material de marca, con un conjunto fijo de poses definido en la guía de marca.
@@ -424,14 +476,16 @@ Todavía no hay mediciones en PC reales en el repositorio. La ISO se prueba en m
### 10.1 Dónde estamos
-Los hitos M1 a M9 están completos en la 0.7.0 Beta: el servidor gráfico, el motor de interfaz, el SDK y los temas, la terminal, los idiomas y las escrituras complejas, la compatibilidad con apps de Linux, los paquetes y los servicios del sistema, las sesiones, el aislamiento y el firewall, y las suites de apps de M9 (documentos e impresión, multimedia, apps del sistema, contraseñas, configuración de hardware, correo y calendario). La ISO final se armó y se probó en máquinas virtuales el 18 de octubre de 2026.
+La 0.8.0 Beta es el primer lanzamiento público; la 0.7.0 fue una compilación interna y nunca se publicó. Los hitos M1 a M9 están completos: el servidor gráfico, el motor de interfaz, el SDK y los temas, la terminal, los idiomas y las escrituras complejas, la compatibilidad con apps de Linux, los paquetes y los servicios del sistema, las sesiones, el aislamiento y el firewall, y las suites de apps de M9 (documentos e impresión, multimedia, apps del sistema, contraseñas, configuración de hardware, correo y calendario). Antes del lanzamiento, las restricciones del firewall que no son de red pasaron a aplicarse para todos los tipos de app, las reglas por dominio tuvieron interfaz en Ajustes y en el Monitor, el arranque sumó una pantalla de carga y un tema de GRUB de LordOS, y los releases sumaron un SBOM firmado y un registro de cambios. La ISO final se armó y se probó en máquinas virtuales el 18 de octubre de 2026.
### 10.2 Limitaciones conocidas
- Hardware real: no se probaron GPU AMD y Nvidia, monitores reales, notebooks (batería, brillo, tapa), controladores Bluetooth, impresoras y escáneres, llaves FIDO2 ni proveedores de correo reales.
-- La Raspberry Pi 5 no se probó con un monitor, y su imagen generada todavía no se arrancó.
-- Las apps de Linux no están aisladas; no hay Xwayland.
-- Firewall: sin modo "preguntar", sin interfaz para reglas por dominio, restricciones que no son de red sin aplicar.
+- La Raspberry Pi 5 es la única placa soportada, con la compilación de LordOS de su kernel con Landlock; no se probó con un monitor, y su imagen generada todavía no se arrancó.
+- Las apps de Linux no están aisladas de forma predeterminada; todavía no hay Xwayland.
+- Firewall: sin modo "preguntar"; las reglas por dominio no ven a las apps que resuelven nombres con su propio DNS cifrado.
+- Las restricciones para apps de Linux no cubren BlueZ por D-Bus, el bus del sistema, el portapapeles ni las apps iniciadas fuera del lanzador de apps; la unión de `user@` también sujeta a los servicios propios del usuario mientras corre una app restringida; un cliente nuevo de PipeWire tiene una ventana de pocos milisegundos antes de que la guardia lo restrinja (§6.6).
+- La clave de firma de `.lpk` todavía es una clave de desarrollo, y todavía no hay un repositorio firmado de apps de LordOS.
- Permisos: no hay "permitir una vez"; no se muestra el uso de cámara y micrófono por parte de apps de Linux.
- Hay que desactivar Secure Boot; la firma con un shim está pendiente.
- Las descargas de paquetes usan HTTP (firmadas y con hash).
@@ -440,7 +494,12 @@ Los hitos M1 a M9 están completos en la 0.7.0 Beta: el servidor gráfico, el mo
### 10.3 Lo que viene
-Antes del lanzamiento final: la ISO final con todo y una imagen para Raspberry Pi 5 probada en la placa real. Después, según lo planeado en `docs/ROADMAP.md`: una app de virtualización de escritorio construida sobre KVM y QEMU; un contenedor Android con LineageOS y apps desde la Tienda de LordOS; el modo "preguntar" del firewall; accesibilidad; y un video de demostración completo.
+Lo próximo, una imagen para Raspberry Pi 5 arrancada y probada en la placa real. Antes de la 1.0, según lo planeado en `docs/ROADMAP.md`:
+
+- **Xwayland**, iniciado a pedido, con el compositor como gestor de ventanas X y las apps X11 con la misma identidad por app, el mismo firewall y las mismas restricciones que las apps Wayland;
+- **el tema Clásico como segunda apariencia completa**: barra de tareas, menú de inicio con búsqueda, bandeja, ajustes rápidos, panel de notificaciones y acomodo de ventanas, con las mismas apps con otra piel, hecho solo con diseño y recursos propios de LordOS.
+
+Después de la 1.0: una app de virtualización de escritorio construida sobre KVM y QEMU; un contenedor Android con LineageOS y apps desde la Tienda de LordOS; el modo "preguntar" del firewall; accesibilidad; y un video de demostración completo.
### Archivos fuente
@@ -486,16 +545,18 @@ openssl pkeyutl -verify -pubin -inkey lordos-release.pub.pem -rawin -in SHA256SU
sha256sum -c --ignore-missing SHA256SUMS
```
+El SBOM de cada arquitectura (`lordos_<version>_<arch>.spdx.json`) también está en `SHA256SUMS`, así que la misma verificación lo cubre.
+
### 11.4 Verificá un sistema en marcha
-- `systemctl status lord-netperm lord-fand lordos` muestra los servicios; la prueba de la ISO confirmó siete programas BPF enganchados.
+- `systemctl status lord-netperm lord-fand lordos` muestra los servicios; la prueba de la ISO confirmó los siete programas de red enganchados. Si el kernel rechaza el programa de dispositivos o el LSM, `lord-netperm` informa `"devices":false` o `"bluetooth":false`.
- `cat /proc/<pid>/status | grep -E 'Seccomp|NoNewPrivs'` sobre un proceso `lord-server --app` muestra la caja de arena.
- `systemd-cgls` muestra el árbol `lordos-session-<uid>`, de root, con un scope por app.
- Escritorio remoto: `ss -ltn` no muestra nada en el puerto 5673 hasta que lo activás en Ajustes → Compartir.
## 12. Licencia y créditos
-El código de LordOS se publica bajo la **licencia MIT**. Los componentes de terceros conservan sus propias licencias, listadas en `THIRD_PARTY.md`: QuickJS y stb (incluidos como código fuente), Monocypher (CC0/BSD-2), la lista de palabras de la EFF (CC BY 3.0 US), la lista de contraseñas comunes (MIT), los datos de países de DB-IP Lite (CC BY 4.0), Natural Earth (dominio público) y las fuentes Inter, JetBrains Mono y Plus Jakarta Sans (OFL).
+El código de LordOS se publica bajo la **licencia MIT**. Los componentes de terceros conservan sus propias licencias, listadas en `THIRD_PARTY.md`: QuickJS y stb (incluidos como código fuente), Monocypher (CC0/BSD-2), la lista de palabras de la EFF (CC BY 3.0 US), la lista de contraseñas comunes (MIT), los datos de países de DB-IP Lite (CC BY 4.0), Natural Earth (dominio público) y las fuentes Inter, JetBrains Mono y Plus Jakarta Sans (OFL). Cada release trae un SBOM SPDX de lo que el paquete incluye y de lo que depende (`docs/COMPLIANCE.md`).
LordOS lo crea el grupo **IPERFEX**: **Pablo Miranda** y **Federico Pereira**.
@@ -505,14 +566,18 @@ LordOS lo crea el grupo **IPERFEX**: **Pablo Miranda** y **Federico Pereira**.
- **cgroup (v2):** un mecanismo del kernel que agrupa procesos para contabilizar y limitar recursos. LordOS le da a cada app su propio grupo, un "scope", y lo usa para identificar la app en el firewall.
- **Compositor:** el programa que combina las ventanas de todas las apps en la imagen final de la pantalla.
- **DRM/KMS:** las interfaces del kernel para los dispositivos gráficos y para configurar los modos de pantalla.
-- **eBPF:** programas pequeños y verificados que corren dentro del kernel; LordOS los engancha a cgroups para decidir sobre las conexiones de red.
+- **eBPF:** programas pequeños y verificados que corren dentro del kernel; LordOS los engancha a cgroups para decidir sobre las conexiones de red, la apertura de dispositivos y los sockets Bluetooth.
- **evdev:** la interfaz del kernel para los dispositivos de entrada.
+- **LSM (BPF LSM):** los ganchos de seguridad del kernel; con el LSM `bpf`, un programa chico enganchado por cgroup puede rechazar una operación, como crear un socket Bluetooth.
+- **Espacio de nombres (namespace):** una función del kernel que le da a un proceso su propia vista de algo (usuarios, montajes, ids de proceso); LordOS usa espacios sin privilegios para las apps de Linux a las que se les restringen los archivos del usuario.
- **Ayudante:** un proceso chico de LordOS que maneja datos no confiables o secretos en una caja de arena más estricta (`lord-doc`, `lord-media`, `lord-maild`, `lord-vault`).
- **Landlock:** una función del kernel que permite que un proceso sin privilegios restrinja qué archivos y puertos de red puede usar él, y sus hijos.
- **`.lpk`:** el formato de paquete de LordOS para apps nativas instalables.
- **`.lvault`:** el formato de archivo de bóveda cifrada de LordOS.
+- **Guardia de PipeWire:** el cliente de PipeWire propio de `lord-server` que les oculta los dispositivos de captura a las apps de Linux restringidas y frena sus streams de captura.
- **Powerbox:** un diálogo de archivos dibujado por el sistema que le da a la app solo el archivo que eligió el usuario.
- **QuickJS:** un motor de JavaScript chico escrito en C.
+- **SBOM:** una lista de materiales de software, el listado legible por máquina de los componentes que contiene un release, en formato SPDX.
- **Scope:** un cgroup para una app, como `app-lordos-lpk-<id>.scope`.
- **seccomp-bpf:** un filtro del kernel que restringe qué llamadas al sistema puede hacer un proceso.
- **Secret Service:** el estándar de D-Bus de freedesktop que usan las apps de Linux para guardar secretos.
@@ -527,8 +592,8 @@ LordOS lo crea el grupo **IPERFEX**: **Pablo Miranda** y **Federico Pereira**.
| 3. Compositor | GPU.md, DISPLAYS.md, WINDOWS.md, TRACKPAD.md, WAYLAND.md, SESSIONS.md, REMOTE.md |
| 4. Motor de interfaz | ARCHITECTURE.md, LANGUAGES.md, TERMINAL.md |
| 5. Aplicaciones | NATIVE-APPS.md, PACKAGES.md, WASM.md, FILES.md, MEDIA.md, DOCUMENTS.md, MAIL.md, ISO.md, INSTALL-DEBIAN.md |
-| 6. Seguridad | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md |
+| 6. Seguridad | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md, COMPLIANCE.md, y `SECURITY.md` |
| 7. Rendimiento | ISO.md, RASPBERRY.md, FANS.md, DISPLAYS.md, GPU.md |
| 8. Experiencia visual | DESIGN.md, LORDOS-BRAND.md, LANGUAGES.md, DOCK.md |
| 9. Extensibilidad | NATIVE-APPS.md, WASM.md, y `apps/README.md`, `themes/README.md` |
-| 10. Hoja de ruta | ROADMAP.md y `CHANGELOG.md` |
+| 10. Hoja de ruta | ROADMAP.md, RELEASING.md y `CHANGELOG.md` |
diff --git a/web/content/paper/paper.pt.md b/web/content/paper/paper.pt.md
index 47d9c20..fea6340 100644
--- a/web/content/paper/paper.pt.md
+++ b/web/content/paper/paper.pt.md
@@ -2,7 +2,7 @@
O LordOS é uma distribuição GNU/Linux livre baseada no Debian 13 que traz um ambiente de desktop próprio, construído a partir dos seus componentes fundamentais sobre Debian e Wayland. Em vez do GNOME ou do KDE, ele tem seu próprio servidor gráfico e compositor Wayland escritos em C (`lord-server`), seu próprio motor de interface (React rodando sobre o motor JavaScript QuickJS, com layout, pintura e texto em código C nativo), seus próprios apps nativos e seus próprios serviços de segurança: um lançador de apps em sandbox, um broker de permissões, um armazenamento de permissões por app, um firewall por app aplicado pelo kernel, assinatura de pacotes e um cofre de senhas criptografado. Ele reaproveita o que é maduro e amplamente revisado: o kernel Linux, o Debian e seus pacotes, Mesa, PipeWire, o protocolo Wayland e algumas bibliotecas (FFmpeg, Poppler, libarchive, OpenSSL, Monocypher) confinadas em pequenos processos ajudantes em sandbox.
-Este documento descreve o projeto e o estado atual da versão **0.7.0 Beta** (outubro de 2026) para um leitor técnico que quer conferir o projeto em vez de acreditar nele. Cada afirmação aponta para um arquivo no repositório público. Os números são os medidos nos registros de teste do projeto e indicam onde foram medidos. O que está projetado mas não construído está marcado como tal.
+Este documento descreve o projeto e o estado atual da versão **0.8.0 Beta** (outubro de 2026), o primeiro lançamento público, para um leitor técnico que quer conferir o projeto em vez de acreditar nele. Cada afirmação aponta para um arquivo no repositório público. Os números são os medidos nos registros de teste do projeto e indicam onde foram medidos. O que está projetado mas não construído está marcado como tal.
## 1. Visão
@@ -55,7 +55,7 @@ Um LordOS em execução tem poucos processos, com papéis bem separados:
|---|---|---|
| `lord-sessiond` | root | tela de login, sessões, empréstimo da tela e da entrada para a sessão visível, área de trabalho remota |
| `lord-netd` | root | a rede do sistema: DHCP, Wi-Fi, VPN; só as ações `net-*` |
-| `lord-netperm` | root (capacidades limitadas) | regras de rede por app, aplicadas com eBPF em cgroups |
+| `lord-netperm` | root (capacidades limitadas) | regras de rede por app, e as restrições de dispositivos e Bluetooth dos apps Linux, aplicadas com programas eBPF de cgroup e de LSM |
| `lord-fand` | root (sem capacidades) | controle das ventoinhas pela temperatura |
| `lord-server` | o usuário | um por sessão: compositor, motor de interface, broker |
| `lord-server --app <id>` | o usuário, em sandbox | um por app `.lpk` em execução (e Senhas) |
@@ -120,7 +120,7 @@ O compositor (`server/src/wl/wl.c`) usa apenas `libwayland-server` e código ger
As janelas Linux entram no gerenciador de janelas do SDK como qualquer outra, com título, foco, maximizar, minimizar e ícone no Dock. Apps que pedem decoração do lado do servidor recebem a moldura do tema; apps que desenham a própria (GTK 4) a mantêm, e a sombra delas é recortada. Apps GTK 4 e libadwaita seguem o modo claro/escuro, a cor de destaque e a ordem dos botões por meio de uma implementação de `org.freedesktop.portal.Settings` que o próprio `lord-server` serve no barramento da sessão; o GTK 3 segue pelo keyfile do GSettings.
-**O Xwayland não é suportado**: o LordOS não roda apps que só falam X11. Também estão pendentes: arrastar e soltar, a seleção primária, os métodos de entrada do LordOS dentro dos apps Linux (`text-input`), ativação (`xdg-activation`), sincronização explícita e ícones de app em SVG. Nenhum protocolo de captura de tela é oferecido aos apps.
+**O Xwayland ainda não é suportado**: o LordOS não roda apps que só falam X11 (o Xwayland está planejado antes da 1.0, §10.3). Também estão pendentes: arrastar e soltar, a seleção primária, os métodos de entrada do LordOS dentro dos apps Linux (`text-input`), ativação (`xdg-activation`), sincronização explícita e ícones de app em SVG. Nenhum protocolo de captura de tela é oferecido aos apps.
### 3.5 Várias telas e HiDPI
@@ -136,6 +136,7 @@ O `lord-sessiond` é o gerenciador de sessões próprio do LordOS:
- **Uma sessão por usuário**, todas podendo existir ao mesmo tempo (troca rápida de usuário). Cada uma é um `lord-server` que começa como root e abandona os privilégios logo em seguida.
- **Empréstimo da tela.** O `lord-sessiond` abre a placa de vídeo e os dispositivos de entrada como root e os empresta à sessão que está no monitor, por um socket Unix. Numa troca, ele os revoga: `EVIOCREVOKE` faz os descritores de entrada da sessão anterior pararem de funcionar, e `DROP_MASTER` retira o controle da tela, antes de qualquer coisa ser entregue à próxima sessão. A sessão visível continua compondo na GPU sem nunca ser root. Uma sessão fora do monitor desenha em memória, e só se alguém a estiver vendo remotamente.
- **Bloquear a tela realmente tira a sessão do monitor**; não é uma camada desenhada por cima. Se a sessão do usuário travar, a tela de login continua funcionando.
+- **Boot.** Um tema de GRUB do LordOS desenha o menu de boot, e um tema de Plymouth do LordOS desenha a tela de abertura (a coroa com uma barra de progresso). A passagem não tem nenhum quadro preto nem texto de console: o Plymouth para de desenhar e solta o controle da tela enquanto seu último quadro continua visível, o `lord-sessiond` assume o controle da tela e mostra o primeiro quadro real da tela de login, e só então o Plymouth termina, mantendo a tela de abertura até ela ser substituída.
**Área de trabalho remota.** O mesmo serviço oferece o desktop a um navegador na rede local, em `https://<endereço>:5673` (5673 soletra "LORD" num teclado de telefone). Ela vem **desligada por padrão** e é ativada em Ajustes → Compartilhar. Usa TLS 1.2 ou superior com um certificado P-256 autoassinado cuja impressão digital os Ajustes mostram para comparação, uma política de segurança de conteúdo rígida, verificação de mesma origem, esperas por IP após logins com falha e um cookie de sessão `Secure`, `HttpOnly` e `SameSite=Strict`. A página de login nunca lista as contas de usuário. O processo que atende uma conexão abandona o root assim que sabe de quem é a sessão. As atualizações de tela vão em PNG quando a imagem está parada e em JPEG durante o movimento. O áudio está projetado, mas não construído. O acesso pela internet não é previsto; recomenda-se uma VPN.
@@ -145,6 +146,7 @@ O `lord-sessiond` é o gerenciador de sessões próprio do LordOS:
- [server/src/input.c](https://github.com/lordbasex/LordOS/blob/main/server/src/input.c), [server/src/tp](https://github.com/lordbasex/LordOS/tree/main/server/src/tp), [server/src/ui/grab.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/grab.c)
- [server/src/wl/wl.c](https://github.com/lordbasex/LordOS/blob/main/server/src/wl/wl.c), [server/src/ui/portal.c](https://github.com/lordbasex/LordOS/blob/main/server/src/ui/portal.c)
- [server/src/remote/sessiond.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sessiond.c), [server/src/remote/monitor.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/monitor.c), [server/src/remote/sess.c](https://github.com/lordbasex/LordOS/blob/main/server/src/remote/sess.c)
+- [tools/boot/plymouth](https://github.com/lordbasex/LordOS/tree/main/tools/boot/plymouth), [tools/iso/grub](https://github.com/lordbasex/LordOS/tree/main/tools/iso/grub), [docs/SESSIONS.md](https://github.com/lordbasex/LordOS/blob/main/docs/SESSIONS.md)
## 4. O motor de interface
@@ -204,7 +206,7 @@ A Loja mostra os apps do Debian por categoria, com busca, além de apps `.lpk` e
### 5.4 Apps Linux
-Apps Linux com um arquivo `.desktop` aparecem no lançador de apps. A abertura passa por `lord.apps.launch(id)`: a interface só pode indicar um arquivo `.desktop` instalado; o `lord-server` o relê, confere, monta o `argv` a partir da linha `Exec` conforme a especificação e o executa com `execve`, sem shell nem argumentos de quem chamou, dentro do seu próprio escopo de cgroup pertencente ao root. Chromium e Firefox vêm pré-instalados na ISO e foram verificados com a moldura do LordOS. **Os apps Linux não ficam em sandbox no LordOS**; eles ganham atribuição e o firewall por app (§6.6).
+Apps Linux com um arquivo `.desktop` aparecem no lançador de apps. A abertura passa por `lord.apps.launch(id)`: a interface só pode indicar um arquivo `.desktop` instalado; o `lord-server` o relê, confere, monta o `argv` a partir da linha `Exec` conforme a especificação e o executa com `execve`, sem shell nem argumentos de quem chamou, dentro do seu próprio escopo de cgroup pertencente ao root. Chromium e Firefox vêm pré-instalados na ISO e foram verificados com a moldura do LordOS. **Os apps Linux não ficam em sandbox por padrão**: eles rodam como o usuário, como em qualquer Debian. Ganham atribuição, o firewall por app e as restrições por app que o dono definir (§6.6), incluindo uma visão opcional "sem acesso aos seus arquivos" aplicada pelo lançador.
### 5.5 WebAssembly
@@ -214,7 +216,7 @@ O LordOS inclui seu próprio interpretador WebAssembly em C (`server/src/wasm`),
- **ISO live** para PCs de 64 bits, com instalador gráfico (UEFI e BIOS).
- **Imagem para Raspberry Pi 5**, para cartão SD ou NVMe (§7.4).
-- **Num Debian 13 já instalado**: `curl -fsSL https://lordos.org/install.sh | sh`. O script pergunta antes de mudar qualquer coisa, baixa o `SHA256SUMS` e verifica sua assinatura Ed25519 com a chave de release embutida no script, recusa continuar sem uma assinatura válida, confere o SHA-256 do `.deb`, instala com o apt e configura o sistema como a ISO. O repositório é privado até a primeira beta pública, então o caminho de download ainda não é público.
+- **Num Debian 13 já instalado**: `curl -fsSL https://lordos.org/install.sh | sh`. O script pergunta antes de mudar qualquer coisa, baixa o `SHA256SUMS` e verifica sua assinatura Ed25519 com a chave de release embutida no script, recusa continuar sem uma assinatura válida, confere o SHA-256 do `.deb`, instala com o apt e configura o sistema como a ISO. Os arquivos do release são publicados no GitHub Releases.
### Arquivos-fonte
@@ -235,7 +237,7 @@ O LordOS é projetado contra estas ameaças:
- **Um atacante na rede local** tentando usar a área de trabalho remota ou adulterar downloads.
- **Pacotes e releases adulterados.**
-Fora do modelo, por enquanto: um kernel ou uma conta root comprometidos; ataques físicos; canais laterais; e apps Linux lendo os arquivos do usuário (eles rodam como o usuário, como em qualquer Debian). Os apps Linux são confinados apenas na rede.
+Fora do modelo, por enquanto: um kernel ou uma conta root comprometidos; ataques físicos; canais laterais; e apps Linux que o dono não restringiu, que rodam como o usuário, como em qualquer Debian, e podem ler os arquivos dele. Os apps Linux são confinados apenas pelas restrições que o dono define para eles (§6.6), e só quando são abertos pelo lançador de apps.
### 6.2 Privilégio mínimo
@@ -255,7 +257,18 @@ Fora do modelo, por enquanto: um kernel ou uma conta root comprometidos; ataques
| `lord-netperm` | `RELOAD` sem dados | rodar programas; receber argumentos; abrir sockets de internet |
| `lord-fand` | `STATUS` para qualquer um; `PROFILE`, `CURVE`, `FORCE` para administradores | indicar caminhos ou dispositivos; rodar programas; usar a rede |
-### 6.4 O sandbox de apps
+### 6.4 O que é isolado, e o sandbox de apps
+
+Nem todo programa no LordOS fica em sandbox. Isto é exatamente o que vale para cada tipo:
+
+| Tipo | Processo | Sandbox | Escopo de cgroup | Broker e permissões | Firewall e restrições (§6.6) |
+|---|---|---|---|---|---|
+| Apps `.lpk` e Senhas | próprio (`lord-server --app <id>`) | Landlock, seccomp, sem capacidades | próprio, do root, com limites | cada chamada é conferida em C | regras de rede e as oito restrições que não são de rede, no broker |
+| Os demais apps incluídos | dentro do `lord-server` | não (fazem parte do desktop) | o do `lord-server` | sem broker; câmera, microfone e tela são conferidos em C | como "LordOS": regras de rede; câmera, microfone, tela e notificações |
+| Apps Linux pelo lançador de apps | próprio | nenhum por padrão; com "sem acesso aos seus arquivos", namespaces próprios de usuário, montagem e PID mais Landlock, a partir da próxima abertura | próprio, do root | não | regras de rede; câmera, microfone, USB, sockets Bluetooth, arquivos e notificações; não a área de transferência |
+| Programas do Terminal | filhos do shell do Terminal | não | o do `lord-server` | não | como "LordOS": regras de rede |
+
+Um programa iniciado de outro jeito, fora do lançador de apps, não está em nenhum escopo de app e não recebe regras por app. Flatpak e bubblewrap não são usados.
Cada app `.lpk`, e o app Senhas, roda como `lord-server --app <id>`: o mesmo binário em "modo app", iniciado pelo `lord-server` com um id de pacote validado como único argumento. O processo se conecta ao compositor como cliente Wayland e abre o socket do broker, depois aplica o sandbox e só então carrega o código do app (`server/src/sec/sandbox.c`):
@@ -280,21 +293,54 @@ O app isolado só fala com o `lord-server` por um socket `SOCK_SEQPACKET`. Cada
- **Revogação:** negar a câmera ou o microfone nos Ajustes os interrompe na hora (o `lord-media` do app é encerrado; o fluxo do PipeWire é fechado). A permissão `network` é decidida na inicialização.
- **Chaveiro:** os pedidos ao chaveiro de um app isolado levam um dono que o `lord-server` define a partir do id verificado do app.
-**Limites.** Não há "permitir uma vez". Algumas permissões declaráveis (Bluetooth, abrir apps, notificações) ainda não têm chamada no broker, então os apps isolados simplesmente não podem usar esses recursos; escutar numa porta depende da permissão de rede. Um app Linux rodando como o usuário poderia editar o arquivo de permissões.
+**Restrições valem mais que permissões.** Uma restrição do firewall (§6.6) vence qualquer decisão salva: o pedido é recusado sem aviso, mesmo que o app já tenha tido permissão, e restringir um app em execução tira dele a câmera e o microfone na hora, como revogar.
+
+**Limites.** Não há "permitir uma vez". Algumas permissões declaráveis (Bluetooth, abrir apps, notificações) ainda não têm chamada no broker, então os apps isolados simplesmente não podem usar esses recursos; escutar numa porta depende da permissão de rede. Um app Linux rodando como o usuário poderia editar o arquivo de permissões, a menos que esteja restrito com "sem acesso aos seus arquivos".
-### 6.6 O firewall por app e o Monitor
+### 6.6 O firewall por app, suas restrições e o Monitor
[[diagram:firewall]]
-O `lord-netperm` aplica regras de rede por app no kernel. Os apps Linux abertos pelo lançador de apps rodam em `app-lordos-<id>.scope`, os apps `.lpk` em `app-lordos-lpk-<id>.scope`, e o resto da sessão conta como `lordos`. Todos os escopos pertencem ao root. O serviço carrega sete programas eBPF de cgroup (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`) no cgroup do `lordos.service`, descobre o app de cada processo pelo seu ancestral de cgroup e devolve permitir ou negar (`EPERM`). Os programas são compilados dentro do binário e carregados com o carregador próprio do LordOS pela chamada de sistema `bpf()`; libbpf e bcc não são usados.
+O `lord-netperm` aplica regras por app no kernel. Os apps Linux abertos pelo lançador de apps rodam em `app-lordos-<id>.scope`, os apps `.lpk` em `app-lordos-lpk-<id>.scope`, e o resto da sessão conta como `lordos`. Todos os escopos pertencem ao root. O serviço carrega sete programas de rede (`connect4/6`, `sendmsg4/6`, `bind4/6`, `sock_create`), um programa de dispositivos (`cgroup/dev`) e um programa LSM por cgroup sobre `socket_create` no cgroup do `lordos.service`, descobre o app de cada processo pelo seu ancestral de cgroup e devolve permitir ou negar (`EPERM`). Os programas são compilados dentro do binário e carregados com o carregador próprio do LordOS pela chamada de sistema `bpf()`, que também lê o BTF do kernel para achar o gancho LSM; libbpf e bcc não são usados. Se o kernel recusar o programa de dispositivos ou o LSM, os programas de rede continuam funcionando e o serviço avisa.
- **As regras** aceitam domínios exatos, curingas, redes IPv4/IPv6, `lan`, `internet`, portas, protocolos e direção. As restrições (sem internet, sem LAN, sem rede, sem conexões de entrada) vêm primeiro; depois vence a regra mais específica, com negar ganhando de permitir em especificidade igual; depois os apps confiáveis; depois o modo (silencioso, o padrão, ou desligado). O `npcompile.c` pré-calcula isso em mapas de hash e de maior prefixo correspondente. Um teste roda o código de decisão do kernel contra o decisor de referência em 480.000 conexões aleatórias: 0 diferenças.
-- **Os nomes de domínio** vêm só do resolvedor do sistema: a interface de monitoramento do systemd-resolved ou, sem ele, respostas da porta 53 dos servidores configurados, lidas por um socket de pacotes que só recebe. Respostas que um app recebeu nos próprios sockets nunca são levadas em conta.
+- **Os nomes de domínio** vêm só do resolvedor do sistema: a interface de monitoramento do systemd-resolved ou, sem ele, respostas da porta 53 dos servidores configurados, lidas por um socket de pacotes que só recebe. Respostas que um app recebeu nos próprios sockets nunca são levadas em conta. Por isso, um app que resolve nomes por conta própria com DNS criptografado (DNS sobre HTTPS dentro de um navegador, por exemplo) não é alcançado pelas regras de domínio: uma regra "permitir só example.com" continua bloqueando-o, mas uma regra "bloquear example.com" não o impede. As regras por endereço e por rede, o padrão do app e suas restrições continuam valendo, e os Ajustes dizem isso abaixo das regras.
+- **As regras na interface.** Ajustes → Privacidade → Regras de rede por app mostra o padrão de cada app ("Permitir tudo" ou "Bloquear tudo exceto as regras") e suas regras na ordem em que vencem, com quando cada uma coincidiu pela última vez; a folha que adiciona uma regra confere o que é digitado enquanto se digita. Em Monitor → Rede, "Permitir / Bloquear este domínio" num destino de um app abre a mesma folha, preenchida com o nome que o resolvedor do sistema deu para aquele endereço.
- **Fugas.** A árvore de cgroups pertence ao root, então um app não consegue se mover. Um processo que pede ao gerenciador systemd do usuário uma nova unidade (`systemd-run --user`) cai sob `user@<uid>.service`; o `lord-netperm` anexa os mesmos programas ali e submete esses processos à união mais estrita das restrições dos apps restritos daquele usuário em execução. Testado: todas as tentativas de fuga negadas, outros usuários não afetados.
- **Custo**: cerca de 0,5 µs por connect UDP, TCP dentro do ruído, nenhuma mudança na vazão, já que nada roda por pacote.
-- **O Monitor** mostra as conexões de cada app (a partir de `sock_diag`), os bytes, os destinos por país a partir de uma base local e um botão de Regra por app. Nenhum endereço sai da máquina para consultas: sem DNS reverso, sem geolocalização online.
+- **O Monitor** mostra as conexões de cada app (a partir de `sock_diag`) e os destinos que o firewall informou há pouco, os bytes, os destinos por país a partir de uma base local e um botão de Regra por app. Nenhum endereço sai da máquina para consultas: sem DNS reverso, sem geolocalização online.
+
+**Restrições além da rede.** Além das quatro restrições de rede (sem internet, sem LAN, sem rede, sem conexões de entrada), o dono pode restringir de um app a câmera, o microfone, a tela, o USB, os arquivos, a área de transferência, o Bluetooth e as notificações. Cada uma é aplicada onde o recurso é entregue, conferida contra o escopo do app e nunca contra um nome que o app dá a si mesmo, e vence qualquer permissão concedida em `permisos.json`.
+
+[[diagram:restrictions]]
+
+| Restrição | Apps `.lpk` e Senhas | Apps incluídos ("LordOS") | Apps Linux pelo lançador de apps |
+|---|---|---|---|
+| câmera | broker (`brokercam.c`) | `js_media.c` | `cgroup/dev` nos nós V4L2, e o guarda do PipeWire |
+| microfone | broker | `js_media.c` | o guarda do PipeWire, e `cgroup/dev` nos nós de captura ALSA |
+| tela | broker (sem API de captura no modo app) | `js_media.c` | por projeto: sem protocolo de captura, sem servidor X, sem portal de captura de tela; `/dev/fb*` negado |
+| USB | broker (a chave de segurança de Senhas) | não oferecida | `cgroup/dev`: nós USB diretos, hidraw e serial USB |
+| arquivos | broker (seletor de arquivos, gravações da câmera) | não oferecida | o lançador: namespaces próprios, uma home em tmpfs e Landlock, a partir da próxima abertura |
+| área de transferência | broker | não oferecida | não disponível |
+| Bluetooth | broker (sem API de Bluetooth no modo app) | não oferecida | programa BPF LSM sobre `socket_create`: sem sockets `AF_BLUETOOTH` |
+| notificações | a permissão `notifications` | `sdk/notify.js` | `notifyd`, pela identidade verificada de quem chama |
+
+Para os apps isolados, o broker (`sec/restrict.c`) é o único ponto de aplicação: um pedido restrito é recusado sem aviso, e restringir um app em execução tira dele a câmera e o microfone na hora (`tests/broker_restrict_test.c` cobre cada restrição, com e sem ela). A linha "LordOS" é o próprio desktop (Arquivos, copiar e colar, Discos, os ajustes de Bluetooth), então ela não oferece arquivos, USB, área de transferência nem Bluetooth; em vez disso, restringem-se apps individuais. Para os apps Linux:
-**Limites.** O modo "perguntar" está projetado, mas hoje se comporta como o silencioso. Ainda não há interface para regras por domínio nem botões por destino (o motor e a API já os suportam). O ICMP só é bloqueado por "sem rede"; conexões a uma porta já aberta não são conferidas. Os Ajustes também oferecem restrições que não são de rede (câmera, microfone, tela, USB, Bluetooth, arquivos, notificações): elas ficam salvas, mas **nenhum componente as aplica ainda**.
+- **Dispositivos.** No cgroup v2, o controlador de dispositivos é um programa BPF. O do `lord-netperm` recusa `open()` e `mknod()` das classes de dispositivo que o app tem restritas (V4L2, USB direto, hidraw, serial USB, nós de captura ALSA, `/dev/fb*`) e permite todo o resto. Vale a partir do próximo `open`; um descritor já aberto continua utilizável.
+- **Sockets Bluetooth.** O gancho de sockets inet nunca vê `AF_BLUETOOTH`, então um programa LSM por cgroup sobre `socket_create` os recusa.
+- **Arquivos.** Logo antes do `execve`, o filho do lançador entra em namespaces próprios de usuário, montagem e PID, sem privilégios. A pasta pessoal é um tmpfs vazio com só as pastas próprias do app (derivadas do seu id de desktop, nunca de campos que um arquivo `.desktop` controla) e o arquivo com que ele foi aberto; a pasta de runtime tem só os sockets do Wayland e do som, então o barramento de sessão e o systemd do usuário ficam fora de alcance; depois o Landlock limita o resto. Vale a partir da próxima abertura. Apps GTK, Firefox e Chromium rodam sem suas integrações de D-Bus.
+- **Notificações.** O `notifyd` pede ao barramento o PID de quem chama (só conta uma resposta enviada pelo próprio barramento), acha o escopo do app e descarta a notificação de um app restrito; um erro ou uma resposta atrasada também a descartam (falha fechada).
+- **Microfone e câmera pelo PipeWire.** O guarda do PipeWire (`sec/pwguard.c`), o cliente de PipeWire próprio do `lord-server`, identifica cada cliente pelo PID que o PipeWire tirou das credenciais do socket e, para um app restrito, esconde os nós de captura e destrói seus streams de captura em menos de um segundo, incluindo uma gravação já em andamento. Enquanto um app restrito roda, um cliente cuja identidade não pode ser estabelecida é tratado como restrito.
+
+**Limites.** O modo "perguntar" está projetado, mas hoje se comporta como o silencioso. O ICMP só é bloqueado por "sem rede"; conexões a uma porta já aberta não são conferidas. As restrições para apps Linux não cobrem:
+
+- o BlueZ via D-Bus: um app com o Bluetooth restrito ainda pode pedir ao `bluetoothd`, pelo barramento do sistema, que procure, pareie e conecte;
+- o barramento do sistema, que continua ao alcance mesmo com "sem acesso aos seus arquivos";
+- a área de transferência;
+- apps iniciados fora do lançador de apps, que não estão em nenhum escopo de app;
+- os efeitos colaterais da união do `user@`: enquanto um app restrito roda, os serviços do próprio usuário ficam sujeitos à mesma união (o áudio de chamadas de um headset, que o PipeWire abre a cada chamada, para durante esse tempo);
+- uma janela de poucos milissegundos em que um cliente novo de PipeWire de um app restrito tem todas as permissões, ou em que um stream de captura pode receber áudio antes de ser destruído.
### 6.7 Ajudantes que processam dados não confiáveis
@@ -312,7 +358,7 @@ O `lord-media` nem sequer recebe o socket do PipeWire; o áudio passa por um ane
Os pacotes `.lpk` trazem um manifesto com o SHA-256 de cada arquivo e uma assinatura Ed25519 sobre ele. SHA-256 e Ed25519 são código próprio do LordOS (o Ed25519 segue a aritmética do TweetNaCl), testados com os vetores do NIST e da RFC 8032 (55 de 55). A verificação acontece em C na instalação e no carregamento. A Loja mostra o nível de confiança: **LordOS** (chave oficial, compilada dentro do binário para que nenhum arquivo possa acrescentar outra), **Autor verificado** (listado no catálogo assinado), **Assinado por <nome>** ou **Não assinado**, com um aviso. As atualizações precisam ser assinadas com a mesma chave. Um catálogo assinado traz uma lista de revogação. Se você editar um app instalado, o LordOS o marca como "Modificado por você", pode restaurar o original ou pode compartilhar sua versão assinada com sua própria chave, dando crédito ao original.
-**Estado:** hoje os pacotes oficiais são assinados com uma chave de desenvolvimento; a chave definitiva a substitui no lançamento público. Um repositório de apps do LordOS assinado para a Loja ainda não foi construído.
+**Estado:** na 0.8.0 Beta, os pacotes oficiais ainda são assinados com uma chave de desenvolvimento, até a chave definitiva substituí-la. Um repositório de apps do LordOS assinado para a Loja ainda não foi construído.
### 6.9 Assinatura dos releases
@@ -320,7 +366,7 @@ Cada arquivo de release (o `.deb`, a ISO e a imagem do Raspberry Pi) aparece com
`c7155b8e6bbbb180f907381994d06af76d333016cd6f3facf67cadd053ea108e`
-A chave privada fica só na máquina do mantenedor, nunca no repositório nem numa máquina de build. A §11 mostra como conferir um download.
+A chave privada fica só na máquina do mantenedor, nunca no repositório nem numa máquina de build. Cada release também traz uma lista de materiais de software (SBOM) SPDX 2.3 por arquitetura, listada no `SHA256SUMS` e portanto coberta pela assinatura, e suas notas saem do `CHANGELOG.md`, mantido no formato Keep a Changelog. A §11 mostra como conferir um download.
### 6.10 O cofre
@@ -330,13 +376,19 @@ O `lord-vault` guarda as senhas e o chaveiro da sessão em arquivos `.lvault`: u
Uma janela marcada como protegida (como a de Senhas) é pintada de preto em todo caminho que copia pixels para fora: capturas de tela, gravações, miniaturas, a área de trabalho remota e os menus e a tela cheia do Wayland. O monitor real a mostra normalmente. Os apps Linux nem têm protocolo de captura de tela, para começo de conversa.
+### 6.12 Divulgação e normas
+
+Vulnerabilidades são relatadas como descreve o `SECURITY.md`, também publicado como `/.well-known/security.txt` (RFC 9116). Os processos do LordOS estão **alinhados com, não certificados em**, ISO/IEC 29147 e ISO/IEC 30111 (divulgação e tratamento de vulnerabilidades), ISO/IEC 5230 (conformidade de licenças do OpenChain: o inventário em `THIRD_PARTY.md`, os avisos de licença e o SBOM) e ISO/IEC 18974 (garantia de segurança do OpenChain: o SBOM mais as atualizações de segurança do Debian para os pacotes de que o LordOS depende). O lordos.org publica as páginas legais e de confiança (política de segurança, assinatura de código, licenças, privacidade, ciclo de suporte, normas) e diz o que ainda falta: sem autocertificação formal, sem cruzamento automático do SBOM com bases de vulnerabilidades, sem SBOM das imagens completas e sem auditoria de terceiros.
+
### Arquivos-fonte
- [server/src/sec/sandbox.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sandbox.c), [server/src/sec/brokersrv.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/brokersrv.c), [server/src/sec/perms.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/perms.c), [server/src/sec/cgroup.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/cgroup.c)
- [server/src/netperm/np.bpf.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/np.bpf.c), [server/src/netperm/netperm.c](https://github.com/lordbasex/LordOS/blob/main/server/src/netperm/netperm.c), [server/src/fw/rules.c](https://github.com/lordbasex/LordOS/blob/main/server/src/fw/rules.c)
-- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh)
+- [server/src/sec/restrict.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/restrict.c), [server/src/sec/pwguard.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/pwguard.c), [server/src/hw/notifyd.c](https://github.com/lordbasex/LordOS/blob/main/server/src/hw/notifyd.c), [server/src/apps.c](https://github.com/lordbasex/LordOS/blob/main/server/src/apps.c), [server/tests/broker_restrict_test.c](https://github.com/lordbasex/LordOS/blob/main/server/tests/broker_restrict_test.c)
+- [server/src/sec/sign.c](https://github.com/lordbasex/LordOS/blob/main/server/src/sec/sign.c), [server/src/pkg/crypto.c](https://github.com/lordbasex/LordOS/blob/main/server/src/pkg/crypto.c), [tools/release/sign-release.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/sign-release.sh), [tools/release/make-sbom.sh](https://github.com/lordbasex/LordOS/blob/main/tools/release/make-sbom.sh)
- [server/src/vault/vault.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vault.c), [server/src/vault/vfile.c](https://github.com/lordbasex/LordOS/blob/main/server/src/vault/vfile.c)
- [server/src/media/capture.c](https://github.com/lordbasex/LordOS/blob/main/server/src/media/capture.c)
+- [SECURITY.md](https://github.com/lordbasex/LordOS/blob/main/SECURITY.md), [docs/COMPLIANCE.md](https://github.com/lordbasex/LordOS/blob/main/docs/COMPLIANCE.md), [CHANGELOG.md](https://github.com/lordbasex/LordOS/blob/main/CHANGELOG.md)
## 7. Desempenho
@@ -396,7 +448,7 @@ Ainda não há medições em PCs reais no repositório. A ISO é testada em máq
## 8. Experiência visual
- **Um guia de design.** Os apps seguem um guia comum (`docs/DESIGN.md`): uma grade de espaçamento de 8 px, uma escala tipográfica enxuta, alturas de controle consistentes e uma única ação na cor de destaque por tela. Os tokens são exportados pelo SDK (`spacing`, `typeScale`, `controlSize`), e cada app passou por rodadas de acabamento documentadas, com antes e depois, nos modos claro e escuro, da direita para a esquerda e em janelas pequenas.
-- **Temas.** Um tema é um desktop completo escrito em React: barra de menus, Dock, lançador de apps, Central de Controle e moldura das janelas, além dos seus tokens. O LordOS traz um tema padrão com barra de menus e Dock, e um tema Clássico com barra de tarefas e menu iniciar. Os temas trocam ao vivo; as configurações persistem.
+- **Temas.** Um tema é um desktop completo escrito em React: barra de menus, Dock, lançador de apps, Central de Controle e moldura das janelas, além dos seus tokens. O LordOS traz um tema padrão com barra de menus e Dock, e um tema Clássico com barra de tarefas e menu iniciar, que hoje é um modelo e vira uma segunda aparência completa antes da 1.0 (§10.3). Os temas trocam ao vivo; as configurações persistem.
- **Claro e escuro, cores de destaque.** Os dois modos e a cor de destaque se aplicam ao vivo aos apps nativos, aos apps isolados e, pelo portal e pelo GSettings, aos apps GTK.
- **Direita para a esquerda.** A interface inteira se espelha para árabe, hebraico e escritas parecidas, incluindo os apps isolados, que seguem o idioma da sessão ao vivo.
- **Lumo.** O mascote do LordOS é o Lumo, uma pequena raposa celestial, usado em telas de boas-vindas, estados vazios e material de marca, com um conjunto fixo de poses definido no guia da marca.
@@ -424,14 +476,16 @@ Ainda não há medições em PCs reais no repositório. A ISO é testada em máq
### 10.1 Onde as coisas estão
-Os marcos M1 a M9 estão completos na 0.7.0 Beta: o servidor gráfico, o motor de interface, o SDK e os temas, o terminal, idiomas e escritas complexas, compatibilidade com apps Linux, pacotes e serviços do sistema, sessões, isolamento e o firewall, e os conjuntos de apps do M9 (documentos e impressão, mídia, apps de sistema, senhas, configurações de hardware, e-mail e calendário). A ISO final foi gerada e testada em máquinas virtuais em 18 de outubro de 2026.
+A 0.8.0 Beta é o primeiro lançamento público; a 0.7.0 foi um build interno e nunca foi publicada. Os marcos M1 a M9 estão completos: o servidor gráfico, o motor de interface, o SDK e os temas, o terminal, idiomas e escritas complexas, compatibilidade com apps Linux, pacotes e serviços do sistema, sessões, isolamento e o firewall, e os conjuntos de apps do M9 (documentos e impressão, mídia, apps de sistema, senhas, configurações de hardware, e-mail e calendário). Antes do lançamento, as restrições do firewall que não são de rede passaram a ser aplicadas para todos os tipos de app, as regras por domínio ganharam interface nos Ajustes e no Monitor, o boot ganhou uma tela de abertura e um tema de GRUB do LordOS, e os releases ganharam um SBOM assinado e um registro de mudanças. A ISO final foi gerada e testada em máquinas virtuais em 18 de outubro de 2026.
### 10.2 Limitações conhecidas
- Hardware real: GPUs AMD e Nvidia, monitores reais, notebooks (bateria, brilho da tela, tampa), controladoras Bluetooth, impressoras e scanners, chaves FIDO2 e provedores de e-mail reais não foram testados.
-- O Raspberry Pi 5 não foi testado com monitor, e a imagem gerada ainda não foi inicializada.
-- Os apps Linux não ficam em sandbox; não há Xwayland.
-- Firewall: sem modo "perguntar", sem interface para regras por domínio, restrições que não são de rede não aplicadas.
+- O Raspberry Pi 5 é a única placa suportada, com o build do LordOS do seu kernel com Landlock; não foi testado com monitor, e a imagem gerada ainda não foi inicializada.
+- Os apps Linux não ficam em sandbox por padrão; ainda não há Xwayland.
+- Firewall: sem modo "perguntar"; as regras por domínio não veem apps que resolvem nomes com o próprio DNS criptografado.
+- As restrições para apps Linux não cobrem o BlueZ via D-Bus, o barramento do sistema, a área de transferência nem apps iniciados fora do lançador de apps; a união do `user@` também sujeita os serviços do próprio usuário enquanto um app restrito roda; um cliente novo de PipeWire tem uma janela de poucos milissegundos antes de o guarda restringi-lo (§6.6).
+- A chave de assinatura de `.lpk` ainda é uma chave de desenvolvimento, e ainda não há um repositório assinado de apps do LordOS.
- Permissões: sem "permitir uma vez"; o uso de câmera e microfone pelos apps Linux não é mostrado.
- O Secure Boot precisa estar desligado; a assinatura com um shim está pendente.
- Os downloads de pacotes usam HTTP (assinados e com hash).
@@ -440,7 +494,12 @@ Os marcos M1 a M9 estão completos na 0.7.0 Beta: o servidor gráfico, o motor d
### 10.3 Próximos passos
-Antes do lançamento final: a ISO final com tudo e uma imagem do Raspberry Pi 5 testada na placa real. Depois dele, como planejado em `docs/ROADMAP.md`: um app de virtualização para desktop construído sobre KVM e QEMU; um contêiner Android com LineageOS e apps da Loja do LordOS; o modo "perguntar" do firewall; acessibilidade; e um vídeo de demonstração completo.
+A seguir, uma imagem do Raspberry Pi 5 inicializada e testada na placa real. Antes da 1.0, como planejado em `docs/ROADMAP.md`:
+
+- **Xwayland**, iniciado sob demanda, com o compositor como gerenciador de janelas X e os apps X11 com a mesma identidade por app, o mesmo firewall e as mesmas restrições dos apps Wayland;
+- **o tema Clássico como segunda aparência completa**: barra de tarefas, menu iniciar com busca, bandeja, ajustes rápidos, painel de notificações e encaixe de janelas, com os mesmos apps com outra pele, feito só com design e recursos próprios do LordOS.
+
+Depois da 1.0: um app de virtualização para desktop construído sobre KVM e QEMU; um contêiner Android com LineageOS e apps da Loja do LordOS; o modo "perguntar" do firewall; acessibilidade; e um vídeo de demonstração completo.
### Arquivos-fonte
@@ -486,16 +545,18 @@ openssl pkeyutl -verify -pubin -inkey lordos-release.pub.pem -rawin -in SHA256SU
sha256sum -c --ignore-missing SHA256SUMS
```
+O SBOM de cada arquitetura (`lordos_<version>_<arch>.spdx.json`) também está no `SHA256SUMS`, então a mesma conferência o cobre.
+
### 11.4 Confira um sistema em execução
-- `systemctl status lord-netperm lord-fand lordos` mostra os serviços; o teste da ISO confirmou sete programas BPF anexados.
+- `systemctl status lord-netperm lord-fand lordos` mostra os serviços; o teste da ISO confirmou os sete programas de rede anexados. Se o kernel recusar o programa de dispositivos ou o LSM, o `lord-netperm` informa `"devices":false` ou `"bluetooth":false`.
- `cat /proc/<pid>/status | grep -E 'Seccomp|NoNewPrivs'` num processo `lord-server --app` mostra o sandbox.
- `systemd-cgls` mostra a árvore `lordos-session-<uid>` pertencente ao root, com um escopo por app.
- Área de trabalho remota: `ss -ltn` não mostra nada na porta 5673 até você ativá-la em Ajustes → Compartilhar.
## 12. Licença e créditos
-O código do LordOS é distribuído sob a **licença MIT**. Os componentes de terceiros mantêm suas próprias licenças, listadas em `THIRD_PARTY.md`: QuickJS e stb (incorporados como código-fonte), Monocypher (CC0/BSD-2), a lista de palavras da EFF (CC BY 3.0 US), a lista de senhas comuns (MIT), os dados de países do DB-IP Lite (CC BY 4.0), Natural Earth (domínio público) e as fontes Inter, JetBrains Mono e Plus Jakarta Sans (OFL).
+O código do LordOS é distribuído sob a **licença MIT**. Os componentes de terceiros mantêm suas próprias licenças, listadas em `THIRD_PARTY.md`: QuickJS e stb (incorporados como código-fonte), Monocypher (CC0/BSD-2), a lista de palavras da EFF (CC BY 3.0 US), a lista de senhas comuns (MIT), os dados de países do DB-IP Lite (CC BY 4.0), Natural Earth (domínio público) e as fontes Inter, JetBrains Mono e Plus Jakarta Sans (OFL). Cada release traz um SBOM SPDX do que o pacote inclui e daquilo de que depende (`docs/COMPLIANCE.md`).
O LordOS é criado pelo grupo **IPERFEX**: **Pablo Miranda** e **Federico Pereira**.
@@ -505,14 +566,18 @@ O LordOS é criado pelo grupo **IPERFEX**: **Pablo Miranda** e **Federico Pereir
- **cgroup (v2):** um mecanismo do kernel que agrupa processos para contabilizar e limitar recursos. O LordOS dá a cada app seu próprio grupo, um "escopo", e o usa para identificar o app no firewall.
- **Compositor:** o programa que combina as janelas de todos os apps na imagem final da tela.
- **DRM/KMS:** as interfaces do kernel para dispositivos gráficos e para configurar modos de tela.
-- **eBPF:** pequenos programas verificados que rodam dentro do kernel; o LordOS os anexa aos cgroups para decidir sobre conexões de rede.
+- **eBPF:** pequenos programas verificados que rodam dentro do kernel; o LordOS os anexa aos cgroups para decidir sobre conexões de rede, abertura de dispositivos e sockets Bluetooth.
- **evdev:** a interface do kernel para dispositivos de entrada.
+- **LSM (BPF LSM):** os ganchos de segurança do kernel; com o LSM `bpf`, um pequeno programa anexado por cgroup pode recusar uma operação, como criar um socket Bluetooth.
+- **Namespace:** um recurso do kernel que dá a um processo sua própria visão de algo (usuários, montagens, ids de processo); o LordOS usa namespaces sem privilégios para os apps Linux restritos dos arquivos do usuário.
- **Ajudante:** um pequeno processo do LordOS que lida com dados não confiáveis ou segredos num sandbox mais rígido (`lord-doc`, `lord-media`, `lord-maild`, `lord-vault`).
- **Landlock:** um recurso do kernel que permite a um processo sem privilégios restringir quais arquivos e portas de rede ele, e seus filhos, podem usar.
- **`.lpk`:** o formato de pacote do LordOS para apps nativos instaláveis.
- **`.lvault`:** o formato de arquivo do cofre criptografado do LordOS.
+- **Guarda do PipeWire:** o cliente de PipeWire próprio do `lord-server` que esconde os dispositivos de captura dos apps Linux restritos e interrompe seus streams de captura.
- **Powerbox:** um diálogo de arquivos desenhado pelo sistema que entrega ao app só o arquivo escolhido pelo usuário.
- **QuickJS:** um pequeno motor JavaScript escrito em C.
+- **SBOM:** uma lista de materiais de software, a listagem legível por máquina dos componentes que um release contém, no formato SPDX.
- **Escopo:** um cgroup para um app, como `app-lordos-lpk-<id>.scope`.
- **seccomp-bpf:** um filtro do kernel que restringe quais chamadas de sistema um processo pode fazer.
- **Secret Service:** o padrão D-Bus do freedesktop que os apps Linux usam para guardar segredos.
@@ -527,8 +592,8 @@ O LordOS é criado pelo grupo **IPERFEX**: **Pablo Miranda** e **Federico Pereir
| 3. Compositor | GPU.md, DISPLAYS.md, WINDOWS.md, TRACKPAD.md, WAYLAND.md, SESSIONS.md, REMOTE.md |
| 4. Motor de interface | ARCHITECTURE.md, LANGUAGES.md, TERMINAL.md |
| 5. Aplicativos | NATIVE-APPS.md, PACKAGES.md, WASM.md, FILES.md, MEDIA.md, DOCUMENTS.md, MAIL.md, ISO.md, INSTALL-DEBIAN.md |
-| 6. Segurança | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md |
+| 6. Segurança | PRIVACY.md, FIREWALL.md, MONITOR.md, SIGNING.md, PASSWORDS.md, MEDIA.md, REMOTE.md, COMPLIANCE.md, e `SECURITY.md` |
| 7. Desempenho | ISO.md, RASPBERRY.md, FANS.md, DISPLAYS.md, GPU.md |
| 8. Experiência visual | DESIGN.md, LORDOS-BRAND.md, LANGUAGES.md, DOCK.md |
| 9. Extensibilidade | NATIVE-APPS.md, WASM.md, e `apps/README.md`, `themes/README.md` |
-| 10. Roadmap | ROADMAP.md e `CHANGELOG.md` |
+| 10. Roadmap | ROADMAP.md, RELEASING.md e `CHANGELOG.md` |