Repository navigation
Releases
v0.9.2
0.9.2 (2026-11-09)
Fixes
v0.9.1
0.9.1 (2026-10-14)
Documentation
v0.9.0
0.9.0 (2026-10-14)
Features
- add Preferences, French and the Colony theme and typography to the app and tray (#80) (fbde21a)
- print the version with --version in the app and tray (#77) (5dee404)
Documentation
v0.8.0
Changed
-
Breaking: a Deny or Reject rule scoped to a program wins over every
Allow rule that names no program, whatever their predicate counts.
deny --exe /opt/agentused to lose toallow --protocol tcp --dst-port 443because the Allow carried more predicates; it now
refuses the agent there too, and the in-kernel connect hooks refuse it
outright. Rules that name a program keep their specificity order among
themselves, soallow --exe X --dst-port 443still beatsdeny --exe X.
Under a generic Allow, a matching program Allow is the rule that answers
and is credited with the hit, so the carve-out keeps a hit count.
A/0network (--dst-net 0.0.0.0/0,::/0) no longer counts as a
predicate when rules are ranked; it still limits a rule to one address
family, and stored rules that carry only a/0keep loading. Some flows
change verdict on upgrade: reviewcfc rules list. -
Breaking: a flow whose process identity is incomplete is prompted
instead of silently refused when a program rule may apply to it: an
unattributed socket (ambiguous UDP, an expired attribution budget), a
binary too large to hash, a process that exited first. The prompt names
the rule that could not be decided (PromptEvent.undecided_rule_id) and
the app, tray andcfc promptsshow the program as unknown. With no UI
connected the flow takesno_ui_action(Deny on every shipped profile),
and prompt caps send overflow there too; pause and the loopback allowance
no longer let such flows through without asking. The in-kernel connect
hooks follow: a running program whose only remaining refusal depends on a
digest the kernel side does not read (adeny --sha256rule, once a
deny --exefor that program is deleted or expires) no longer keeps a
kernel refusal that failed itsconnect()with no prompt; the packet
path decides it. One "allow
this program" rule no longer blocks every unattributed flow that a
generic rule allows.
The reverse holds: once any program Deny or Reject exists, a flow whose
program is unknown no longer passes a generic Allow it matches (that Deny
may be about it), and no Allow rule can settle it; scope the Deny to
destinations or make attribution succeed. A--sha256Deny without
--exedoes this to every image over 64 MiB (Chromium, Electron, VS
Code); add--exeto it.
The event log and live feed record the undecided rule inrule_idwith a
source other thanrule. A legacy hostname rule that cannot be decided is
still refused. Withno_ui_action = "Allow", a program can reach that
fallback by making its own attribution fail, so keep it at Deny where
program denies matter. -
New loopback flows now go through the queue instead of being accepted
outright (oifname "lo" acceptis gone from the outbound table). While the
daemon runs, explicit rules apply to them, so a loopback Deny that 0.7.0
never enforced now takes effect, and unmatched local IPC is still allowed
without a prompt. Each new loopback connection pays the queue round trip. -
Socket attribution is stricter. TCP needs an exact connected tuple and never
selects a listening socket, so an outbound flow no longer inherits a
listener's rules. UDP accepts zero-remote and wildcard-local sockets only
when every compatible socket agrees on its owner. The process and
descriptor found must still hold the socket after the executable is read;
otherwise the identity is unknown. -
GUI: "make rule" on a Live row seeds the program, port and protocol, the
scopecfc rules add --exe --dst-port --protocolbuilds, instead of
pinning the one address seen, which left the app denied on its next
address (#46). A row without an identified program pins the address and
never seeds<unknown>; an inbound row keeps its direction and is scoped
on the peer seen and the local port, since the daemon refuses our own
address as an inbound destination. "Customize" on a prompt seeds the same
way. A saved rule logs the scope it stored, and a rule the editor refuses
is also reported in the footer. -
GUI: a prompt arriving while others are pending no longer switches to the
Prompts tab; only the first one does, and raises the window. -
cfc rules import-opensnitchstops before changing anything when a source
rule cannot be converted (hostname and regexp rules among them), because
dropping a narrow deny next to a broad allow imported a wider policy than
the source with only a skip count to show for it.--skip-unconvertible
imports the rest, naming each skipped file. Breaking for scripts that
relied on the old additive behaviour. -
Bundles name the binary that connects. The rules for Firefox on Arch, git,
cargo under rustup and apt pinned a launcher or front end that never shows
up as the connecting executable, so they never fired.webanddevdrop
Epiphany, npm and pip, whose traffic comes from a shared WebKit helper or
an interpreter. Hosts that installedweb,devorupdatesbefore keep
the old rules:cfc rules bundle remove NAMEthenbundle add NAME
replaces them, andbundle addnames each one that pins an old path. -
Rule summaries in the GUI and
cfc rules listshow the protocol, a uid and
[pinned]for a hash-pinned rule, so a scoped rule no longer reads as
global. -
cfc rules exportwritesexpires_at_unix_msfor timed rules, and import
keeps that deadline instead of starting the full lifetime again. Older
versions refuse an export that contains the field. -
Confinement: a refused launch exits 125 and its reason is in
journalctl -u cfc-app-ID.service; it used to be discarded and reported
as the application's status 1. -
The release tarball ships
install.shanduninstall.sh, generated from
pkg/colony.json. No Colony app store client ever read that manifest or
ran itspostInstall/preRemove, so the tarball had no installer and the
documented store channel did not exist; the docs now say so. -
Lifting filtering is
systemctl disable --now colony-firewall-nft(plus
colony-firewalldto keep it off), not a plain stop. A stop or restart
propagates through the network managers'Requires=to NetworkManager and
systemd-networkd. The docs now carry ruleset changes as a local copy loaded
through a unit drop-in: a same-named table from/etc/nftables.confis
replaced at boot, on daemon start and on every upgrade.
Security
-
Breaking: only root and the installed app and tray may change the
firewall. Group membership no longer grants control. A non-root peer may
answer prompts, add, edit or delete rules, pause, resume or import only when
its process runs the installed, root-sealed/usr/bin/colony-firewallor
/usr/bin/colony-firewall-tray(by device and inode), sealed itself at
startup (inherited descriptors closed, non-dumpable), holds the connection
itself, is not traced, runs under no seccomp filter (one installed before
execcan fake the descriptor closing), runs in the host namespaces and
mapped no executable file from outside root-owned directories. Every other
program of the
desktop user, a non-rootcfcincluded, is read-only: its changes are
refused with the reason (exit 1 incfc), its prompt subscription does not
count as a connected UI and it cannot answer prompts. A peer with the
daemon's own uid keeps full control (root in production). New
[ipc] official_clientskey;require_groupnow waives the group check
for the app and tray only. See docs/HARDENING.md for what this still
trusts. One of those routes is a program that starts the app or tray
underptraceand patches it before it seals itself, which the default
Yamaptrace_scope = 1allows; the daemon warns at startup until
kernel.yama.ptrace_scopeis 2.
The tray now takes a prompt notification's answer only from the
notification server's own bus connection: the button signal is one any
session-bus program can emit, and the tray, trusted by the daemon, used to
act on it, so a program could press "Always allow app" on its own prompt. -
Breaking: pause, resume and rule import from the app or tray ask for an
administrator password through polkit
(org.projectcolony.firewall.pause, asked every time, and
org.projectcolony.firewall.import-rules, kept a few minutes). Pause is
not kept because any program of the user can click the tray's menu over
D-Bus. Storing an enabled Allow rule that names no program
(allow --protocol tcp), from the rule editor or a customized prompt
answer, asks too (org.projectcolony.firewall.allow-every-program, kept a
few minutes): it lets every program through, which is what a pause does,
and it was the way around the pause password. The policy file is
installed by every package; polkit is an optional dependency. Root is
never asked, and answering a prompt or editing a rule that names a
program, or a Deny, never asks. The tray no longer blocks its prompt
notifications while the dialog is open.Upgrading from 0.7.0:
- Scripts that ran
cfcas a regular user to change rules, pause or
answer prompts must usesudo cfc. Reading (status,rules list,
log,live) is unchanged. - Restart Colony Firewall and its tray after the upgrade, and after every
later one. The 0.7 processes, and any process still running a replaced
binary, are read-only until relaunched: the tray says so in a
notification, a refused prompt answer shows the daemon's reason, and
such a process stops counting as a UI at the next prompt, so later
prompts are not held for the full timeout. The pacman and RPM scriptlets print
this on every upgrade. - Pausing from the app or tray needs a polkit agent in the session
(most desktops run one; on Hyprland,hyprpolkitagent). Without one
the request is refused with that reason andsudo cfc pauseworks. - A...
- Scripts that ran
v0.7.0
Added
cfc applications runandstopprovide opt-in, administrator-controlled
confinement for fresh headless application trees. Network access is denied
by default;--allow IPapproves exact numeric peers for the whole tree
across TCP/UDP ports, including any relay that peer provides. Ordinary CFC
rules can further restrict new connections. Revocation stops the complete tree.- The initial confinement profile requires x86_64 Linux, cgroup v2, systemd
262+, Bubblewrap 0.13+, working system D-Bus and libbpf interface filters.
Launches verify the native filters and require a sealed runtime on a
supported local filesystem. Private namespaces, dropped capabilities and
seccomp restrict local relays and inherited resources. Desktop services,
shared home directories, standard input/output and live grant changes are
unavailable. This mode covers only explicitly launched trees; ordinary
socket attribution and established-flow authorization remain unchanged.
Security
- All profile defaults now refuse unattended and unanswered connections.
Explicit administrator overrides remain supported. Incomplete process
identity and compatible undecidable rules refuse before pause or prompts. - Fast Allow is disabled in every runtime configuration, including existing
fast_allow = truesettings. Allowed flows use NFQUEUE. - Hostnames are diagnostic only. New hostname rules and imports are rejected;
compatible legacy hostname rules refuse before a lower Allow or fallback.
Replace them explicitly with executable or numeric destination scopes. - New executable rules require the canonical target explicitly instead of
silently rewriting aliases. This does not recover legacy alias intent or
pin future executable contents; hash scopes remain a separate control. - Parsed NFQUEUE Deny/Reject decisions commit to SQLite before their verdict
or live publication. Audit failure drops the packet and stops the worker.
Kernel drops, malformed packets and journal delivery are outside this gate. - Enabled nftables units load independently before daemon initialization and
are required by NetworkManager and systemd-networkd. Failed table loading
blocks those managers; daemon failure leaves filtering installed. This
contract excludes initramfs networking and already configured interfaces. - Control mutations verify each peer's actual group credentials. Non-root
prompt replies require delivery to that user, persisted prompt Allows retain the
prompted image binding, and rule imports publish committed batches atomically. - Packet attribution, rejection parsing and eBPF object selection validate
their inputs more strictly. Build jobs use read-only repository permissions;
release publication runs after successful builds with separate write access.
v0.6.0
Changed
- The minimum supported Rust version increased from 1.88 to 1.89. Source
builds and package builders now require Rust 1.89 or newer. - Updated
notify-rustto 4.18.0,dns-lookupto 4.0.1,futuresto
0.3.34,chronoto 0.4.45, andipnetto 2.12.2. - Updated the pinned Rust toolchain GitHub Action.
v0.5.0
Security
- The fast path could grant what the packet path denies. The two deciders
did not read the same uid: the packet path takes the uid from the kernel's
exec record, the grant path resolves it from/procat the time it decides.
For a program that drops privileges afterexec-named,postfix, a
browser entering its sandbox - those differ, sodeny --exe X --uid 0above
allow --exe Xwas answered "deny" by one and "allow" by the other. A grant
is process-wide and destination-blind, so the deny was not slower, it never
applied. The grant side now abstains wherever a uid-scoped rule could reach
the program, exactly as the deny side already did; those flows take the
queue, where the uid has one answer. Hosts with no uid-scoped rule are
unaffected. - A rule that could not be decided was walked past.
matches_process
collapses "cannot say" into "does not match", so adenyscoped to
exe_sha256over a binary the daemon cannot hash - over 64 MiB, unreadable,
or a process whose image is already gone - handed the flow to a
lower-precedenceallow. The deny listed, ranked first and never fired.
RuleSet::lookupis now three-valued: a rule that is about this flow but
undecidable stops the walk, and the default applies instead of a rule its
author wrote it to override. The connection half is tested first, so a rule
its own destination excludes still abstains for nothing. - Hostnames observed on the wire could admit traffic. Nothing correlates
an observed DNS response to a query this host sent - the kernel gate is
source port == 53and no more - so any peer answering from that port could
assert any name for its own address and inherit whatever adst_hostrule
allows it. Such a name may now refuse but may not admit; a reverse lookup,
which is forward-confirmed, still does both. Deny rules written against a
name keep working exactly as before, which is why the check runs one way
only. - ICMP refusals were emitted for multicast and broadcast destinations,
sourced from the group address. Inbound,dst_ipis this machine - and
for mDNS, SSDP, LLMNR or a DHCP offer it is the group the datagram was sent
to. Refusing those put a martian source on the wire, one packet per packet
received, at every neighbour that speaks multicast: an RFC 1122 and RFC 4443
violation, a way to enumerate CFC hosts on a segment, and an answer to the
DHCP server that breaks the lease. Both endpoints must now be ordinary
unicast addresses before anything is forged. - Refusals that leave the machine are budgeted. The destination came
straight from the packet with no limit of any kind, so a spoofed source
address turned the daemon into an unthrottled ICMP reflector -nft reject
cannot be used that way because the kernel rate-limitsicmp_send, and a
raw socket withIP_HDRINCLis governed by nothing. Twenty per second off
the machine, with a burst of twenty. Refusals to a local application are not
budgeted: throttling those would restore the timeout the feature replaces. cfc statusreportedenforcingforever once it had seen one packet.
The counter only goes up, so after the first connection the answer was "yes"
for the daemon's life - including afternft flush rulesetor a firewall
reload took the table away and the machine stopped being filtered. A packet
counter cannot tell "nothing is filtered" from "nothing is happening", so
the daemon now asks nftables directly, once a minute, and says what it
found. An absent table inside the startup grace period is not alarming: the
shipped units start the daemon before the one that loads the table.- An
exe_pathfrom the wire was unbounded. A 4 MiB path passed every
gate and then drove onecanonicalize(2)per component - millions of
syscalls - on the sixteen-slot blocking pool the prompt router also uses.
Rules now refuse a path longer thanPATH_MAX, which no process could match
anyway. The rejection deliberately does not echo the path back. docs/HARDENING.mdunderstated the DNS risk it described. It framed a
forged observed answer as something an attacker must race the resolver for,
"the same attacker who could also forge the forward lookup FCrDNS depends
on". That is not the shape: nothing correlates an observed response to a
query this host sent, so any peer the host sends a datagram to can reply
from source port 53, with no spoofing and no guessing, and the application's
own resolver never sees it. The section now says so, and says what the
daemon does about it.ListEventsskipped an unbounded number of rows.limitwas clamped
andoffsetwas not, so a read-only peer could make sqlite step and discard
the whole event table per call, holding the global connection mutex.
Fixed
- Four raw sockets received a copy of every TCP segment and every ICMP
packet on the machine, for the daemon's whole life. They exist only to
send refusals and are never read, butIP_HDRINCLgoverns sends alone: the
kernel clones every matching packet into a buffer that could only fill and
drop. They now carry a one-instruction filter that returns zero, the
standard way to say send-only. Opened unconditionally at start, so this was
a tax on every host running CFC, whether or not any rule ever rejected. - The hostname cache had no upper bound on one of its two insert paths. A
completed reverse lookup re-created its own key even when the reservation
had already been evicted, so the map ratcheted upward by one per orphaned
completion on any workload touching more distinct destinations than it
holds. A completion with nothing to update is now dropped.
Performance
- One netlink socket per thread instead of one per queued packet.
Attribution opened, configured and closed anAF_NETLINKsocket for every
packet the queue handed up, on the single datapath thread. Measured on
scripts/vm-bench: 0.28 ms of every queued flow at 3000 flows. Reuse is
only safe because each request now carries its own sequence number and the
reply is checked against it - every request used to carryseq = 1, so a
late answer to a timed-out request would have been indistinguishable from
the next one's, which is a wrong attribution rather than a slow one. The
socket is discarded on anything but a cleanly-sequenced answer.
Added
scripts/vm-bench, which measures what the firewall costs on a machine
it is allowed to arm. It assembles an initramfs from this host's own kernel
modules, nftables, iproute2, python3 and the release binaries, boots it under
KVM, and runsscripts/bench-latency.shthere against a real daemon - queue
rule loaded, rules imported, fast path granting. Nothing is downloaded and
nothing outsidetarget/vm-benchis written. Each state differs from its
neighbour in one thing, and two facts are recorded beside every measurement
rather than assumed: whatcfc statussays the fast path is, and how many
packets the kernel actually handed to userspace.
Fixed
docs/ARCHITECTURE.mddescribed a design that had been replaced. It
said the NFQUEUE worker blocks inrecvwhile no prompt is outstanding -
"no polling, no added latency" - which is the designnfqueue.rsreplaced,
and the opposite of what the shipped daemon does.nfqueue.rspredicted half the idle beat per queued flow; it is a whole
one. "Mean: half that" holds for arrivals independent of the beat, not for
a client connecting in series, where every connect lands just after the
worker committed to a fresh wait. Measured by building the same daemon with
RECV_POLL_INTERVALat 200 us and running both in one guest.
Measured
- What the fast path is worth, per new outbound TCP flow, median, on Linux
7.2.2 under KVM: 0.0269 ms against 7.6083 ms through the queue at 3000
flows, and 0.0268 against 5.6745 at 300. It costs 0.011 ms over having no
firewall at all, and unlike the queue its cost does not grow with load,
because those flows never reach the daemon.TODO.md1a carries the whole
table and what is still unattributed.
v0.4.0
Added
-
Fast allow (opt-in,
[ebpf] fast_allow = true). A process a lasting
rule allows outright no longer pays an NFQUEUE round trip per connection:
thecgroup/connect4|6hooks mark its TCP sockets with a value the daemon
draws at random on each start, and ameta mark @fast_allow acceptrule the
snippet ships with an empty set takes them ahead of the queue. New
sendmsg4|6hooks run the same decision for UDP sends that carry a
destination; since no UDP socket is ever marked, what they do there is strip
a mark that should not be present. Grants
reach processes that were already running, not only ones that exec after
the rule: the daemon walks/procat start and at every rule change. The
mark is re-decided at every hook that opens a flow and stripped when the
grant is gone; the kernel clears grants on exec and exit by itself; and a
CLOCK_BOOTTIMEdeadline the daemon refreshes means a dead daemon leaves
the machine fail-closed again within one deadline - 60 s, refreshed every
10 s, or the shorter pair below. Fast-allowed
flows are reported on a ring, with their destination named from the same
reverse-DNS cache the packet path uses, so the live feed, rule hit counts
and theenforcingheuristic keep telling the truth. Off by default for
this first release;cfc statusand the startup log line show
fast-allow liveoroff: <the one reason>.Two things worth knowing before turning it on. Only TCP sockets are
marked, deliberately: they are the only ones that pass a hook again, and
the mark lives on the socket, so a mark given to anything else could never be
taken back - not by a revocation, not by the deadline, not by the daemon
dying. It costs little where it lands: a UDP peer that answers makes the flow
conntrack-established and its later datagrams were not being queued anyway,
so a marked UDP socket only kept gaining while its peer stayed silent, which
is exactly when an unrevocable mark does the most damage. What is given up in
practice is the fast path for QUIC. And the mark shares one 32-bit word with
everything else on the machine: the daemon refuses values that collide with
the fwmark selectors it knows (kube-proxy's two single-bit masks,
Tailscale's, wg-quick's), and[ebpf] fast_allow_markpins one by hand for a
host with a selector it does not know.Two kernel facts weaken the guarantee without switching the path off, and
cfc statussays which: the exec/exit tracepoint links could not be pinned
(a read-only bpffs; perf-event links have been pinnable since 5.15), or the
exit tracepoint has nogroup_deadand a process's death cannot be told from
one of its threads' - absent on 5.10 and 6.12 in the kernel matrix, present
on 6.18. In both cases the grant deadline drops from sixty seconds to six,
refreshed every two; in the second the daemon also re-checks every granted
pid's start time on every beat and drops any that changed hands, since there
the kernel's own eviction can miss a death while the daemon is alive. That
second case was a refusal in the first design, which put the fast path out
of reach of every kernel RHEL ships.The
cgroup/sendmsghooks are no longer required: with no UDP socket ever
marked they can only strip a forged mark, so where the kernel refuses them
(5.10 does) the path runs and the report notes what it runs without. On a
restart the previous daemon's cookie-variant marker in bpffs is what tells
the new one that the pinned connect programs carry the mark decision. -
scripts/bench-latency.sh, the veth bench the fast path has to be
measured on: a network namespace on the other end of a veth pair, a TCP
listener on each side, and connect latency in both directions reported as
percentiles. It never touches nftables, the daemon or its rules; run it
once per state and compare, on a VM where CFC may be armed. -
The kernel matrix brackets RHEL 9. A 5.15 entry joins 5.10: the LTS
below and the LTS above the 5.14 that Rocky and RHEL 9 ship. What both
allow, 5.14 allows unless Red Hat took it out; what only 5.15 allows, 5.14
has only if they backported it; what both refuse, 5.14 may still have
through a backport. Where the two disagree is the list of things to check
on a Rocky host rather than assume. The first 5.15 run named one: it
already takes the sendmsg hooks that 5.10 refuses, and neither has
group_dead. -
The startup report says what the fast path's kernel side is capable
of (fast_path=ready|sendmsg-unavailable|basic-connecton the log line,
nonewhere no connect hook attached), and the matrix test asserts it per
kernel, along withgroup_dead, wherever a run has already shown the
answer: 5.10 takes the connect hooks and refuses the sendmsg ones, 5.15 and
6.12 take both and still have nogroup_dead, 6.18 and 7.1 have
everything. A kernel that changes its answer fails in CI rather than
degrading quietly on a host; one without a recorded answer is printed, and
the matrix summary carries the line.
Changed
- Three costs removed from paths every process on the machine takes, none of
them measured on a live kernel yet, each argued from what the code does
rather than from a number. The exec and
exit programs deleted a fast-allow grant on everyexecveand every exit,
unconditionally, on hosts where the feature is off (which is every host by
default); the delete is now behind one array read of the mark, which is
UNARMEDexactly when the grant map is empty. Withdrawing the fast path left
FAST_ALLOW_MARKarmed in the pinned map, so a daemon restarted with
fast_allow = falseafter an unclean death made every TCPconnect()pay a
getsockoptand two map reads to strip a mark nobody would ever set, for as
long as it ran; withdrawing unarms. And the/procwalk that re-seeds grants
on every rule change now asks first whether any rule could grant anyone, and
a rule set of denies, timed allows and port-scoped allows is answered in a
few comparisons instead. The verifier counts in the kernel matrix are the one
measurement these changes get, and a count is not a runtime cost - the exec
program may well verify a few instructions longer for the branch that lets
it skip a hash delete at runtime. - eBPF ABI v4. New maps and programs the connect hooks read; v3 pins
would enforce fine and never mark, so a restarting daemon now replaces
them rather than inheriting them.verdict::ALLOW, matched by the kernel
and written by nobody for two releases, is gone. - The daemon now runs
nftto put its fast-allow value into one set and
take it out again - the first time it touches nftables; the SELinux policy
grants exactly that. The set is flushed at every start of the daemon - with
the layer on, switched off in the config, or absent from the build - so a
daemon that crashed while armed and came back in any of those states does
not leave its predecessor's mark accepted; and once armed the daemon re-checks
every minute that the element is still there, so annft -fthat reloads
the ruleset is noticed and re-armed rather than reported as live. The
nftables snippet gains the set and the accept rule; an older snippet leaves
fast-allow off with the reason spelled out.
Fixed
- The RPM spec still said 0.2.3 in the 0.3.0 tree, and nothing ran to say
so:scripts/check-versions.shnow holds the spec, the PKGBUILD and the
Colony manifest toCargo.tomlon every push, not only when a packaging
path changes.
Internals
- Two integration tests that each copied a binary and spawned it raced each
other's fork (ETXTBSY on CI, the window between a fork and its exec, where
the child still holds the other test's write descriptor); copy and spawn
are now serialised behind one lock instead of retried past the race. - Dependency bumps: rusqlite 0.40.2, libc 0.2.189, flate2 1.1.10,
owo-colors 4.4.0, thiserror 2.0.20;action-gh-release3.0.3.
v0.3.0
Added
- Hash-bound prompt allows. Answering a prompt for a user-writable binary
now binds the rule to the binary's sha256 rather than to its path, so a
replacement does not inherit the permission the user granted the original. - Tray icon fallback, so the indicator still appears where the themed icon
cannot be loaded. - RPM packaging, built end to end in CI alongside the Arch package.
Fixed
- Forty-seven findings from an adversarial audit of the 0.2.x line. The
one critical: the SELinux policy granted three capabilities it did not need. - The VM matrix and SELinux CI jobs, whose failures had been masking each
other across nine rounds.
Internals
- The parchment palette now comes from
colony-uirather than from eleven
hand-maintained constants incfc-ui. The eleven names and their values are
unchanged, so no call site moved. colony-ui0.1.4, which fixes six palettes whose progress-bar track was the
same colour as the card it sat on.
v0.2.3
Added
-
Inbound filtering. CFC now filters both directions, under one policy:
nothing enters without a rule, and inbound never prompts - an exposed
machine is scanned continuously, and a bubble per inbound SYN would be a
denial of service on the user's attention. A separate opt-in unit
(colony-firewall-nft-inbound) loads a fail-closed chain (policy drop),
guarded twice at start: the daemon must be active, and a lockout pre-flight
refuses to load if a live remote session has no rule to readmit it after a
restart. Theinboundbundle seeds mDNS/LLMNR/DHCP/SSH scoped to private
ranges only. -
In-kernel enforcement that survives the daemon - for new processes too.
The daemon compiles its process-wide deny rules into a pinned kernel table
(EXE_RULES); the exec tracepoint consults it and writes verdicts itself.
Kill the daemon: processes it knew keep their EPERM, and a denied binary
launched afterwards is refused in 0 ms by the kernel alone. The daemon
became a control plane. The exit tracepoint now evicts its own verdicts
(using the kernel'sgroup_dead, resolved from the live tracepoint format),
so the pinned map cannot rot through pid recycling. -
Content-bound rules.
cfc rules add --exe <path> --pin-hashbinds a
rule to the binary's sha256: replace the file and the rule stops applying,
instead of the replacement inheriting the permission. Per-rule and off by
default - a package update revokes such a rule too, by design. -
cfc statusnow reports where enforcement lives (pinned,inherited,
process,unavailable) - losing the kernel layer is otherwise silent. -
eBPF backend. Compiled into the daemon by default; still gated at
runtime by[ebpf] enabled, which remains off. Build without it with
cargo build -p cfc-daemon --no-default-features.
Three kernel programs:sched_process_exec/sched_process_exit
fill a kernel-sourced process table, so attribution no longer races a
short-lived process through/proc;cgroup_skb/ingressobserves the
DNS answers this host actually receives, and those outrank
PTR-derived names in the hostname cache. Verified live on kernel
7.1.8. The daemon degrades tosock_diag+/proc+ PTR whenever the
feature is off, the object is missing, or the load fails. -
colony-firewall-tray: a system-tray icon (StatusNotifierItem, so KDE
and most bars natively; GNOME needs the AppIndicator extension) in the
Windows Firewall Control mold. Shows enforcing / paused / unreachable
at a glance, flags waiting prompts (attention icon + a rate-limited
desktop notification), offers Pause 5 min / 30 min / 1 h / daemon
default and Resume, and opens the GUI on left-click. Autostarts with
the session; quitting the tray never touches the daemon. -
The GUI honors
$CFC_SOCKET, so it can be pointed at a daemon on a
non-default socket (a--dry-runinstance, a test socket) without a
rebuild - the CLI already had--socketfor this. -
bootstrap-defaultsnow also seeds the DHCP clients (dhcpcd,
NetworkManager, systemd-networkd; v4 renewals on 67/udp and DHCPv6 on
547/udp). With enforcement starting before the network is configured,
these are what let astrictmachine get a lease at boot.
Changed
-
Inbound connect latency 2.78 ms -> 0.13 ms (the packet path no longer
performs a socket lookup that cannot succeed for an inbound SYN); daemon
RSS 78 MB -> ~31 MB; 18 threads -> 7; SQLite in WAL at full durability,
2.5x faster event batches. Measured on a veth pair, method in the repo. -
Filtering now starts before the network does. Both units are
orderedBefore=network-pre.target(the systemd firewall convention)
instead of after it: the daemon is listening on the queue and the
nftables table is loaded before NetworkManager, systemd-networkd or
dhcpcd configure a single interface. There is no window at boot where
the network is up but filtering is not. The nft unit alsoWants=the
daemon, so enabling enforcement alone pulls the daemon in.
Fixed
- The inbound bundle opened three UDP ports to the whole internet. Its
mDNS, LLMNR and DHCP entries shipped without a source network, admitting
unicast UDP from any address on earth; the comment above them promised the
opposite. Now one entry per private range, with a bundle-wide test. - A rule scoped to
exe_path = "<unknown>"- the display placeholder for an
unattributable process - matched every unattributable flow, which is every
inbound flow. Four locks: the matcher, the API, load-time, and both UIs. parent_exewas counted in rule precedence but never compared, so a rule
carrying it matched every process while outranking narrower rules. Refused
at the API boundary until it can actually be evaluated.- An unset rule direction now means outbound - its meaning before inbound
filtering existed - instead of silently widening every pre-existing rule
into an inbound admission the day the input chain is enabled. - An unparseable inbound packet takes
inbound_action(which cannot be
Allow) instead ofno_ui_action(which can). - Deleting a deny rule now reliably lifts its in-kernel verdict, including
for processes older than the attribution table's TTL.