Lisa Blog

Harbor: where Lisa's applications come from

· The Lisa team
harborapplicationssecurityrelease

Every application on a Lisa machine, after the first boot, comes from one place: Harbor. Harbor is the store you see, and the tooling behind it that gets an application from its source code to a person’s desktop, safely.

This post is about how that works, and about the one rule that shapes all of it.

Applications travel in signed sets

Lisa does not install applications one package at a time. Applications travel in sets: a signed record of every application, each with its id, name, version, source repository, commit and tree digest. A set is published on the same signed channel as the OS itself, on its own lineage, verified with the same trusted root and the same key roles.

There is no second trust path. A machine that cannot verify an OS image cannot verify an application either, and the reverse holds too.

Because applications have their own lineage, they update on their own. An OS update never touches the applications a person has, and a new set of applications does not need a new OS. They are shipped and signed separately, and verified the same way.

No sideloading

If it is not in a signed set, Harbor cannot install it. There is no “open this file to install” and no unknown-sources switch.

Developers are not left out. Their route is Developer Mode: a machine-level setting that only an administrator can turn on, separate from the store and visible as such. It is specified and not built yet. Until it is, we put our own development builds on a test machine by hand. What a person installs from Harbor is always something the release authority signed.

Harbor asks; the daemon writes

The Harbor window never fetches the channel itself. A privileged daemon, harbord, does that, because the trusted root belongs to the machine and verification is root’s job. harbord:

  1. fetches the applications lineage;
  2. verifies the timestamp, snapshot and targets against the image’s trusted root;
  3. checks the payload’s signed digest;
  4. accepts a set only after it has unpacked and verified whole.

It is the only thing that writes which set is active. It stages, activates and rolls back sets, each time with the person’s consent.

What the window shows is what the daemon accepted, rendered verbatim: Discover is the newest set’s own record, and Updates compares that record with what is installed. Every page shows where an application came from, including the repository, commit, tree hash and release, and never recalculates it. When the channel is unreachable, Harbor shows the cached catalogue with a plain notice of when it last fetched. It never invents an entry and never reports a false success.

We proved the round trip on a real machine on 14 September. Through the window, with consent each time, we rolled back to the previous set and then restored the current one. The window and an independent read of the active set agreed at every step, and a test file in an application’s data kept its exact contents, permissions and owner throughout.

The store is not an app in the store

Harbor is a system application. It ships inside the OS image and updates only when the OS does. It is never a member of an application set: Installed never offers to remove it. A machine whose set is empty or cannot be verified must still have the place applications come from. So the store cannot be removed by the same mechanism it manages.

The other half: getting an app into a set

Harbor’s second half lives in the developer’s tools. The coder publish commands validate a bundle, build an application set, verify it, and prepare an unsigned publication candidate.

The unsigned part is deliberate: signing is not Harbor’s. The release authority signs and uploads, as it does for the OS. Today that is how Lisa’s own applications reach the channel: About, Calculator, Coder, Surfer and the rest are built by the release cycle, signed into a set, and published.

The store’s door: written, not built

Our next step is to let developers outside Lisa publish. We have written that door down in full (the Developer Program behind a Lisa ID), and built none of it yet. It works like this:

  • Enrolment gives a publisher two things: a publisher id (a reverse domain they prove they control; app.lisaos.* stays Lisa’s) and a publisher key. The developer’s machine makes the key pair, and the store never holds a publisher’s private key.

  • A submission is one signed bundle plus the words for its page. Before a person sees it, the store checks, in order:

    • the publisher is enrolled;
    • the app id lies under the publisher id;
    • the signature and every file hash match;
    • the same validate command the authority uses passes;
    • the version is higher than any version already signed;
    • the name and icon are the bundle’s own.

    The first failure refuses the submission, with a sentence saying which check it was.

  • Review, then a set. An approved submission goes into a set that the release authority signs. It reaches the developer channel first and then graduates to beta and stable, the same bytes each time, by the authority’s decision and never on a timer.

  • Revocation. A compromised key is revoked by a signed, dated, irreversible entry on a revocation list on the same channel. A machine stops installing and updating that publisher’s apps. What is already installed keeps running, Harbor shows why, and the person is told once.

One rule holds through all of it: a machine never reads the store. It reads the sets and the revocation list on the channel, and trusts only Lisa’s root. The store, Lisa ID and every publisher’s server can all be down without a machine losing install, update or recovery.

What is not done

  • The store’s door is written and nothing behind it is built. No publisher other than Lisa exists, no publisher key has been issued, and the revocation list does not exist yet.
  • Agents can’t drive Harbor yet. Its agent tools are not bound.

It is all on Harbor’s page in the docs.

← All posts