Skip to content

Releases

v0.9.2

Choose a tag to compare

@github-actions github-actions released this 09 Nov 20:04
38752ca

0.9.2 (2026-11-09)

Fixes

  • deps: update dependencies, pin Rust 1.99.1 and fix the open security advisories (#94) (229b755)

Code signing policy

v0.9.1

Choose a tag to compare

@github-actions github-actions released this 24 Oct 10:43
ea934c4

0.9.1 (2026-10-14)

Documentation

  • bring back the table of known limits that are not bugs (#83) (aa928c2)

Code signing policy

v0.9.0

Choose a tag to compare

@github-actions github-actions released this 14 Oct 13:36
029699c

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

  • install the polkit policy in the manual setup and correct the end-to-end test status (#74) (67681b2)
  • stage the polkit policy in the local tarball recipe and describe the inbound profile difference (#75) (31a3e46)

Code signing policy

v0.8.0

Choose a tag to compare

@github-actions github-actions released this 08 Oct 13:04
6a6e228

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/agent used to lose to allow --protocol tcp --dst-port 443 because 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, so allow --exe X --dst-port 443 still beats deny --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 /0 network (--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 /0 keep loading. Some flows
    change verdict on upgrade: review cfc 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 and cfc prompts show the program as unknown. With no UI
    connected the flow takes no_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 (a deny --sha256 rule, once a
    deny --exe for that program is deleted or expires) no longer keeps a
    kernel refusal that failed its connect() 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 --sha256 Deny without
    --exe does this to every image over 64 MiB (Chromium, Electron, VS
    Code); add --exe to it.
    The event log and live feed record the undecided rule in rule_id with a
    source other than rule. A legacy hostname rule that cannot be decided is
    still refused. With no_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" accept is 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
    scope cfc rules add --exe --dst-port --protocol builds, 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-opensnitch stops 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. web and dev drop
    Epiphany, npm and pip, whose traffic comes from a shared WebKit helper or
    an interpreter. Hosts that installed web, dev or updates before keep
    the old rules: cfc rules bundle remove NAME then bundle add NAME
    replaces them, and bundle add names each one that pins an old path.

  • Rule summaries in the GUI and cfc rules list show the protocol, a uid and
    [pinned] for a hash-pinned rule, so a scoped rule no longer reads as
    global.

  • cfc rules export writes expires_at_unix_ms for 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.sh and uninstall.sh, generated from
    pkg/colony.json. No Colony app store client ever read that manifest or
    ran its postInstall/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-firewalld to 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.conf is
    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-firewall or
    /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
    exec can 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-root cfc included, is read-only: its changes are
    refused with the reason (exit 1 in cfc), 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_clients key; require_group now 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
    under ptrace and patches it before it seals itself, which the default
    Yama ptrace_scope = 1 allows; the daemon warns at startup until
    kernel.yama.ptrace_scope is 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:

    1. Scripts that ran cfc as a regular user to change rules, pause or
      answer prompts must use sudo cfc. Reading (status, rules list,
      log, live) is unchanged.
    2. 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.
    3. 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 and sudo cfc pause works.
    4. A...
Read more

v0.7.0

Choose a tag to compare

@github-actions github-actions released this 30 Sep 20:45
a2f928f

Added

  • cfc applications run and stop provide opt-in, administrator-controlled
    confinement for fresh headless application trees. Network access is denied
    by default; --allow IP approves 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 = true settings. 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

Choose a tag to compare

@github-actions github-actions released this 28 Sep 13:51
d09c6eb

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-rust to 4.18.0, dns-lookup to 4.0.1, futures to
    0.3.34, chrono to 0.4.45, and ipnet to 2.12.2.
  • Updated the pinned Rust toolchain GitHub Action.

v0.5.0

Choose a tag to compare

@github-actions github-actions released this 30 Sep 20:45
fa9efc3

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 /proc at the time it decides.
    For a program that drops privileges after exec - named, postfix, a
    browser entering its sandbox - those differ, so deny --exe X --uid 0 above
    allow --exe X was 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 a deny scoped to
    exe_sha256 over a binary the daemon cannot hash - over 64 MiB, unreadable,
    or a process whose image is already gone - handed the flow to a
    lower-precedence allow. The deny listed, ranked first and never fired.
    RuleSet::lookup is 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 == 53 and no more - so any peer answering from that port could
    assert any name for its own address and inherit whatever a dst_host rule
    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_ip is 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-limits icmp_send, and a
    raw socket with IP_HDRINCL is 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 status reported enforcing forever 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 after nft flush ruleset or 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_path from the wire was unbounded. A 4 MiB path passed every
    gate and then drove one canonicalize(2) per component - millions of
    syscalls - on the sixteen-slot blocking pool the prompt router also uses.
    Rules now refuse a path longer than PATH_MAX, which no process could match
    anyway. The rejection deliberately does not echo the path back.
  • docs/HARDENING.md understated 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.
  • ListEvents skipped an unbounded number of rows. limit was clamped
    and offset was 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, but IP_HDRINCL governs 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 an AF_NETLINK socket 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 carry seq = 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 runs scripts/bench-latency.sh there against a real daemon - queue
    rule loaded, rules imported, fast path granting. Nothing is downloaded and
    nothing outside target/vm-bench is written. Each state differs from its
    neighbour in one thing, and two facts are recorded beside every measurement
    rather than assumed: what cfc status says the fast path is, and how many
    packets the kernel actually handed to userspace.

Fixed

  • docs/ARCHITECTURE.md described a design that had been replaced. It
    said the NFQUEUE worker blocks in recv while no prompt is outstanding -
    "no polling, no added latency" - which is the design nfqueue.rs replaced,
    and the opposite of what the shipped daemon does.
  • nfqueue.rs predicted 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_INTERVAL at 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.md 1a carries the whole
    table and what is still unattributed.

v0.4.0

Choose a tag to compare

@github-actions github-actions released this 30 Sep 20:46
dc39346

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:
    the cgroup/connect4|6 hooks mark its TCP sockets with a value the daemon
    draws at random on each start, and a meta mark @fast_allow accept rule the
    snippet ships with an empty set takes them ahead of the queue. New
    sendmsg4|6 hooks 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 /proc at 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_BOOTTIME deadline 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 the enforcing heuristic keep telling the truth. Off by default for
    this first release; cfc status and the startup log line show
    fast-allow live or off: <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_mark pins 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 status says 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 no group_dead and 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/sendmsg hooks 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-connect on the log line,
    none where no connect hook attached), and the matrix test asserts it per
    kernel, along with group_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 no group_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 every execve and 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
    UNARMED exactly when the grant map is empty. Withdrawing the fast path left
    FAST_ALLOW_MARK armed in the pinned map, so a daemon restarted with
    fast_allow = false after an unclean death made every TCP connect() pay a
    getsockopt and two map reads to strip a mark nobody would ever set, for as
    long as it ran; withdrawing unarms. And the /proc walk 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 nft to 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 an nft -f that 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.sh now holds the spec, the PKGBUILD and the
    Colony manifest to Cargo.toml on 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-release 3.0.3.

v0.3.0

Choose a tag to compare

@github-actions github-actions released this 02 Sep 11:06
04c8212

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-ui rather than from eleven
    hand-maintained constants in cfc-ui. The eleven names and their values are
    unchanged, so no call site moved.
  • colony-ui 0.1.4, which fixes six palettes whose progress-bar track was the
    same colour as the card it sat on.

v0.2.3

Choose a tag to compare

@github-actions github-actions released this 27 Aug 18:37

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. The inbound bundle 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's group_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-hash binds 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 status now 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/ingress observes 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 to sock_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-run instance, a test socket) without a
    rebuild - the CLI already had --socket for this.

  • bootstrap-defaults now 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 a strict machine 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
    ordered Before=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 also Wants= 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_exe was 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 of no_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.