# Porta: notes for IT review

> Clarida Porta for IT review: outbound HTTPS only, one local listener, an Ed25519 key per machine, code-signed, and every component it ships, with licenses.

Source: https://clarida.bio/security/porta
Updated: 2026-11-10

[Security](https://clarida.bio/security)

Porta, a Windows service, lets Clarida fetch run files from a lab PC. It connects out over HTTPS and listens only on that machine.

Last updated November 10, 2026

## 1. What Porta is

Porta is a small Windows service that runs on a machine in your lab, typically the PC attached to a qPCR instrument. It lets Clarida read run data from that PC, so results reach your analysis without a USB stick or an emailed export.

The core does three things: connectivity, identity and folder reading. Instrument integrations are separate components, each its own executable, and each can be switched off.

One such component exists today, for the Roche LightCycler 480. It reads finished runs from that instrument's own database instead of waiting for an export. It is installed with the agent but does nothing until a member of your workspace configures it, and it can be blocked on the PC itself.

### At a glance

- Outbound HTTPS on port 443 to one Clarida server; no inbound firewall rule ([section 2](https://clarida.bio/security/porta#network-and-firewall)).
- One local listener, 127.0.0.1:7676, for the setup page on that PC ([section 2](https://clarida.bio/security/porta#network-and-firewall)).
- A Windows service, running as LocalSystem ([section 7](https://clarida.bio/security/porta#what-runs-on-the-machine)).
- An Ed25519 key made on the PC, held with DPAPI, replaced every 90 days ([section 3](https://clarida.bio/security/porta#identity-and-authentication)).
- Reads the folders and instruments configured in Clarida, when a person asks ([section 5](https://clarida.bio/security/porta#what-porta-can-read)).
- No shell commands, no changes to what it reads, no self-update ([section 6](https://clarida.bio/security/porta#what-leaves-the-machine)).
- Installer, agent and instrument component signed by Clarida ([section 7](https://clarida.bio/security/porta#what-runs-on-the-machine)).
- Uninstall deletes the key; revoking in Clarida needs no access to the PC ([section 8](https://clarida.bio/security/porta#removing-it)).

### Known limits

- Any account able to log in to the PC can use the setup page, to pair the agent elsewhere too ([section 2](https://clarida.bio/security/porta#network-and-firewall)).
- The setup page does not check the Host header, so a web page open on that PC could reach it ([section 2](https://clarida.bio/security/porta#network-and-firewall)).
- Any member of the owning workspace chooses what is served, a whole drive included ([section 5](https://clarida.bio/security/porta#what-porta-can-read)).
- The owning workspace reads all that the connector serves ([section 5](https://clarida.bio/security/porta#what-porta-can-read)).
- Whoever controlled our servers could command every connected agent ([section 3](https://clarida.bio/security/porta#identity-and-authentication)).
- The instrument password sits in readable form in the configuration file ([section 6](https://clarida.bio/security/porta#what-leaves-the-machine)).
- A database backup can hold an instrument password for 7 days ([section 6](https://clarida.bio/security/porta#what-leaves-the-machine)).
- While the instrument component runs, the password is on its command line ([section 6](https://clarida.bio/security/porta#what-leaves-the-machine)).
- Any member of the owning workspace can read that password back from the agent ([section 6](https://clarida.bio/security/porta#what-leaves-the-machine)).
- Every account on the PC can read the agent's log ([section 6](https://clarida.bio/security/porta#what-leaves-the-machine)).
- Shawl, the service wrapper, is not signed by Clarida ([section 7](https://clarida.bio/security/porta#what-runs-on-the-machine)).

## 2. Network and firewall

Porta opens a TLS connection out to Clarida on port 443 and keeps it open. Status, file requests and key renewal travel over it. Pairing, and Disconnect on the setup page, are each one separate HTTPS request to the same server. A plain-HTTP address is refused, except a loopback one during development.

### What this means for your firewall

- No inbound firewall rule is required. Porta never asks to be reachable from outside.
- No port forwarding, static IP, VPN or DMZ.
- The only address it connects to is the Clarida URL shown in the app when you pair it, on port 443.
- Porta has no proxy setting and needs direct outbound HTTPS. Behind TLS inspection, pairing fails.
- The agent opens the connection. There is no route from the internet to the lab machine. TLS ends at Fly.io, our hosting provider, in front of our servers.

### The one listening socket, and its scope

Porta serves a small setup page on the lab machine, bound to 127.0.0.1 on port 7676. A port scan of the machine shows it. The page runs whenever the service does, so the machine's owner can always see what is shared. It shows the workspace, the folders, the active capabilities and every share. It never returns the private key, a pairing code or an instrument password.

Binding to loopback keeps every other computer off the page. It does not check who is signed in to the PC itself. Any account able to log in there can open the page and act on it: pair the agent with another server (the folders already configured stay), disconnect it, or lift a block. The agent runs as LocalSystem, so a server paired this way can name any folder on the PC and read it past the file permissions. Workspace administrators are not emailed when that happens; the agent's own log records the new pairing. The page does not check the Host header, so a web page open in a browser on that PC could reach it through DNS rebinding and do the same. The boundary is access to the lab machine.

Check it yourself: in `netstat -ano`, the agent's process listens on 127.0.0.1:7676 and nowhere else.

## 3. Identity and authentication

Porta authenticates with an Ed25519 key pair that it generates on your machine. Only the public key is sent to Clarida. On every connection the agent proves who it is by signing a fresh challenge from the server.

Clarida holds no secret that could impersonate your agent, so a breach of our systems yields no credential for your lab. Whoever controlled our servers could still command every connected agent: list and read its folders, and add new ones.

### How the agent is first authorized

- A member of your workspace generates a one-time pairing code in Clarida.
- That code is pasted into the setup page on the lab machine. It lasts 24 hours, can be used once and is scoped to one workspace.
- The agent generates its key pair and registers the public half; the code is then used up. From then on the key pair is what authenticates.

### Revocation

A connector can be revoked from Clarida at any time, and revocation is permanent. A revoked connector cannot be restored: that would trust again the key that prompted the revocation. A revoked agent is refused when it authenticates, whatever remains installed on the lab machine. Revoking also ends a live session within 30 seconds.

If a PC is lost, stolen or decommissioned, revoking the connector cuts it off, with no access to the machine needed. Pairing codes are separate: valid for 24 hours, single-use, and stored only as a hash, so an unused code cannot be recovered from Clarida.

The agent also replaces its own key pair every 90 days, over its authenticated connection. Clarida retires the old key once the new one has connected.

Revocation can also start at the machine. The setup page has a Disconnect action: the agent signs a request with its own key telling Clarida to revoke the connector, then deletes that key locally whether the server answered or not. The signed message names the connector and a time, and Clarida refuses it after five minutes, so a captured request cannot be replayed later or pointed elsewhere. Workspace administrators are emailed that it was disconnected at the machine, as distinct from revoked in the app.

The endpoint that accepts a pairing code is rate limited, and a failed attempt does not say whether a code was wrong, expired or already used. A code carries about 192 bits of randomness, so guessing one is not a practical attack.

Workspace administrators are emailed when:

- a connector is paired
- a connector is revoked
- a connector is disconnected at the machine
- a connector is deleted
- a new pairing code is issued
- a capability is switched on
- a folder is added
- a share is accepted
- a shared folder moves to another path

No email goes out when an instrument password changes, a share code is created or a block is lifted at the machine.

## 4. The private key on disk

The agent's private key is held on the lab PC with the Windows Data Protection API (DPAPI), at machine scope. It is not stored as readable text.

Machine scope binds the key to the PC that created it. Copying the configuration file to another computer yields no usable Clarida credential, because the key cannot be unprotected anywhere else. The same file holds an instrument password in readable form, and that works wherever the device can be reached ([section 6](https://clarida.bio/security/porta#what-leaves-the-machine)).

DPAPI does not bind the key to a privilege level, so the folder's access control is the second half of the protection. The installer sets it: inherited permissions are replaced so that only SYSTEM, LOCAL SERVICE and members of the Administrators group can read the folder. An ordinary signed-in user on that PC is denied access to the file.

The agent checks that second half instead of assuming it. When it starts, it reads the permissions on its own state folder; if they allow more readers than they should, it says so on its setup page and in the service wrapper's log, not in the activity log of section 6. It reports and never changes permissions itself. A machine set up some other way than our installer is told on its setup page when it is less protected than this note describes.

DPAPI is a Windows mechanism. The agent also runs elsewhere for development and testing, with no equivalent protection; that build is not what we distribute.

## 5. What Porta can read

Nothing, until it is configured. A new agent, once paired, serves no folders and is connected to no instrument. Any member of your workspace can name a folder, anywhere on the machine, a whole drive included. Administrators are emailed when one is added. The same goes for an instrument's address and password.

### Confined to the folders you name

Each configured folder is a root. Every requested path is resolved and then checked to lie inside its root before anything is read. Anything that resolves outside its root is refused, whether it gets there through "..", an absolute path or a link. The boundary holds for each root. A root is whatever folder someone names.

### Requested, never volunteered

Porta does not watch folders and does not push files up on its own. A person in your workspace asks for a listing or a specific file, and the agent answers that request. The lab PC stays the source; Clarida reaches in only when asked.

Each transfer, of a file or an instrument run, is capped at 12 MiB. A larger one is refused, not sent; it is uploaded in Clarida instead.

### Shared with another workspace

A connector belongs to the workspace that paired it, which alone configures it. Where several groups use one instrument, each in its own workspace, the owner (typically the facility) can open part of the connector to another group's workspace: named folders and, on a LightCycler 480, parts of its database. Nothing is shared by default.

- A share is created by an owner or administrator of the owning workspace, as a one-time code that expires after 24 hours and is stored only as a hash. It takes effect only when an administrator of the other workspace accepts it.
- The other workspace can list and read within what was shared, and nothing else. It cannot configure the connector, and never learns where a shared folder lives on the PC.
- The agent has one identity and cannot tell workspaces apart, so Clarida holds this boundary. Each request from another workspace is checked against its share before it reaches the PC. Instrument listings are filtered to what was shared, and anything outside it is refused. A request whose origin is neither the owner nor an active share is not delivered.
- Either side can end a share at any time. Taking a folder off the connector removes it from every share. Pointing a shared folder elsewhere emails the owner's administrators: it changes what the other side can read.

Two limits: the owning workspace can read everything the connector serves, as it could at the instrument PC. And the setup page shows the machine's owner what each workspace can reach. Who asked is in Clarida's record of each request; the agent's log can't tell workspaces apart.

## 6. What leaves the machine

### Continuously

While connected, Porta reports its status every 10 seconds: the agent version, which capabilities are installed and enabled, and basic machine details for troubleshooting, namely hostname, operating system, architecture and runtime. It does not report the logged-in user, internal IP addresses or instrument serial numbers.

### On request

Listings and files from the configured folders, when a workspace member asks for them. On a configured instrument, the list of runs and the run data itself, likewise only when asked. Also on request: the list of folders it serves, and an instrument's settings, password included.

### The instrument password

Connecting to an instrument needs its password. This is where it travels and rests.

- You type it once, in Clarida. It travels down the encrypted connection to the agent.
- The password sits in our record of the delivery, and in the agent's reply, until the command ends, normally within 30 seconds; then both are cleared. Our database is backed up once a day and each backup is kept for 7 days. A backup can hold a password delivered shortly before it was taken.
- Clarida copies the instrument's host, port and username so its interface can show them. An allowlist keeps the password out: a field is copied only if it is named, so a new one is withheld by default.
- The lab machine holds the password in two files, both in the agent's restricted folder. One is protected by DPAPI, as the agent's key is. The other is the configuration file, where it sits in readable form, as Clarida delivered it, until a later change without a password replaces it.
- While the instrument component runs, the password is also on its command line: administrators can see it there, and process auditing (Windows event 4688, Sysmon, an EDR) records it.
- The password field in Clarida is write-only. The agent itself returns the password when asked for its settings. Clarida's interface never asks for them. Any member of the owning workspace may, as may anyone who controls our servers.

Our live database holds no instrument password once a delivery ends. A backup from the last 7 days can. What we hold is that one is configured, and whether it last worked.

### What the agent will not do

- It does not run arbitrary commands. The agent implements a fixed, named set of capabilities decided at build time; an instruction naming anything else is refused, not run. There is no shell, and no way for text from the server to become a command.
- It does not modify, move or delete anything it reads. Both capabilities only list and read. The one thing written to disk is the LightCycler 480 component's temporary export of a run, in the system temp folder, deleted as soon as it has been read. On an instrument it logs in, reads finished runs and logs out; it never alters the database or starts a run.
- It does not scan the machine, list drives or index anything outside the configured folders.
- It does not reach across your network on its own. The instrument capability connects to one address you supply, and only when asked; it discovers and probes nothing.
- It does not update itself. There is no update mechanism in the agent at all; new versions are installed deliberately by an administrator. Porta never downloads or runs code on its own.

Clarida chooses which of those fixed capabilities runs and supplies its parameters, the served folders included. It cannot add a new operation, and no instruction from it clears a block set locally on the PC. Anyone signed in at the machine can lift that block.

### What Clarida records of each request

Which file was requested from which machine, by whom, and when. The record keeps that description. The file itself passes through our database on its way to you and is cleared once delivered. A backup from the last 7 days can still hold it. Members of the owning workspace can read the record, including requests made through a share; the other side cannot. Folder paths in it are visible to your workspace; they are not secrets.

### A record you hold yourself

The agent writes its own log on the lab PC, in a folder every account there can read and only the service and administrators can change. It records:

- start and stop, and each connection
- every file, listing and instrument request, and whether it succeeded
- which file in which folder was read, and its size (for an instrument run, the size only)
- a capability blocked or unblocked on the PC
- the first pairing and each later one, Disconnect, and key rotation

Configuration pushed from Clarida is not in it; that is in the record above. It cannot say which workspace or person asked. Treat the folder paths it records as visible to anyone who can sign in there.

This makes our claims checkable without our cooperation: read the PC's own log, or point your log collector at it. It records paths and sizes, never file contents or key material, and it is size-capped so it cannot fill a disk.

It is not tamper-proof: an administrator on that PC could edit it. Its value is that it is independent of Clarida.

## 7. What runs on the machine

Porta installs as a standard Windows service, set to start automatically so it survives a reboot. It runs under the LocalSystem account. Installation requires administrator rights, as service registration and writing to Program Files do. Using it afterwards needs none, and neither does pairing it again from its setup page ([section 2](https://clarida.bio/security/porta#network-and-firewall)).

It ships as a self-contained executable with its own bundled Python runtime, so nothing needs installing first and Porta does not interfere with other software on the PC. The one exception is the LightCycler 480 component, which needs Roche's LIMS Interface Module on the same PC.

### The installer is code-signed

The installer, the agent and the instrument component are signed by Clarida, and every signature is timestamped, so it stays valid after the certificate expires. Shawl, the service wrapper, is not signed by Clarida. The Digital Signatures tab of the installer's properties names us, and the Windows prompt shows Clarida as the verified publisher, not "Unknown".

Check it yourself: `Get-AuthenticodeSignature` on the installer names the signer.

### You will still see a SmartScreen warning

Signed and recognized are different things. SmartScreen will show "Windows protected your PC" and call the app unrecognized. Choose "More info" to reveal the "Run anyway" button. It is not on the first dialog, which makes the download look blocked when it is not.

SmartScreen builds reputation per file, from how many people have downloaded and run it. A newly published build has no such history, so it is unrecognized whoever signed it. Our certificate comes from Microsoft's Artifact Signing service, not the extended-validation kind that brings reputation with it, so each new version starts that count again.

The signature means the publisher in that dialog is verified, not self-asserted. An unsigned installer would show no publisher at all. If your policy doesn't permit clicking through SmartScreen, tell us; we'd like to know it is blocking you.

### Instrument components

Instrument capabilities are separate components, not part of the core. Each is its own executable, launched as a separate process, so a fault in one cannot destabilize the connection or the agent itself. They run under the same LocalSystem account: the separation contains a crash, not a privilege. Each is signed on its own, so the signature you check on the agent does not vouch for code it does not contain.

The LightCycler 480 component is a 32-bit executable, unlike the 64-bit agent, because Roche's interface is 32-bit COM and a 64-bit process cannot load it. That is why the installer carries a second, smaller Python runtime; both are listed in [section 9](https://clarida.bio/security/porta#what-it-is-built-from). It is installed with the agent and, like the folder capability, does nothing until configured and can be blocked on the PC.

### Local control over what is enabled

Each capability sits at one of three levels: installed, enabled or blocked. Enabling is done from Clarida by your workspace; blocking is done locally, from the setup page.

A local block wins. It is stored outside the settings Clarida can push, so no instruction from our side clears it. If someone blocks file access on that PC, nothing in Clarida turns it back on; it has to be unblocked at the PC itself. Instrument and file access are separate decisions; neither implies the other.

## 8. Removing it

Uninstalling stops and removes the Windows service, and deletes the agent's stored credential. The private key does not survive an uninstall, so a decommissioned PC is not left holding a key that still authenticates.

This is not offered as a prompt during uninstall. Whether an orphaned credential matters is not a judgment the person clicking Uninstall can reasonably make, so uninstalling always deletes it. An administrator who means to keep a pairing should back up the configuration first, and the backup restores only on the same PC; otherwise the machine pairs again with a fresh code.

Upgrading is unaffected. Installing a new version over an existing one keeps the credential, so an update never forces a new pairing.

The service wrapper's own log is removed too. What stays behind, in the agent's folder (`C:\ProgramData\Clarida\Porta`), is the activity log of section 6 and, if an instrument was ever configured, the file holding its password, still protected by DPAPI. Neither lets anything connect to Clarida. Both can be deleted freely, and the password file should be, on a machine leaving your control.

Uninstalling does not revoke the connector in Clarida; the two are separate actions. An uninstalled agent stops connecting and shows as offline, but its record stays until someone revokes it. We recommend both: uninstall on the PC, then revoke in Clarida to close the record.

Either one alone stops the agent, and for a lost or compromised PC revocation is the one that matters, since it needs no access to the machine. The private key existed in one place, and uninstalling deletes it: the agent cannot reconnect even while its record is open.

## 9. What it is built from

Every third-party library is code we ship into your lab. 3 libraries are chosen directly; 7 more arrive as their dependencies. Of these, all but one are permissively licensed. The exception is certifi, the list of trusted authorities, under the MPL-2.0, a file-level copyleft license.

The listing below is everything a scan of the installer finds, not only what we chose. Three more things ship inside it: the bootloader PyInstaller places in each executable (GPL-2.0, with an exception for that use); Shawl, the small program that runs the agent as a service; and two packages the build pulls in unused.

### Chosen directly

| Package | Version | License | Why it is there |
| --- | --- | --- | --- |
| `cryptography` | 50.0.2 | Apache-2.0 OR BSD-3-Clause | Ed25519 key generation and signing: the agent proves its identity to Clarida on every connection. |
| `httpx` | 0.28.1 | BSD-3-Clause | The two one-off HTTPS calls outside the persistent connection: exchanging the pairing code for a registered identity, and the setup page’s Disconnect. |
| `websockets` | 17.3 | BSD-3-Clause | The outbound connection the agent holds open to Clarida. |

### Required by the above

| Package | Version | License | Why it is there |
| --- | --- | --- | --- |
| `anyio` | 4.15.1 | MIT | Async plumbing used by httpx. |
| `certifi` | 2026.10.23 | MPL-2.0 | The list of certificate authorities httpx trusts, for the pairing and Disconnect requests. The open connection uses the Windows store instead. |
| `cffi` | 2.1.1 | MIT-0 | Lets cryptography call its native code. |
| `h11` | 0.16.0 | MIT | HTTP/1.1 protocol handling, beneath httpx. |
| `httpcore` | 1.0.9 | BSD-3-Clause | The transport layer httpx is built on. |
| `idna` | 3.20 | BSD-3-Clause | Internationalized domain name handling, required by httpx. |
| `pycparser` | 3.12 | BSD-3-Clause | Used by cffi at build time. |

### Instrument component libraries

Every machine gets the instrument components' libraries. They load only when that instrument is configured, and a scan of the installer reports them.

| Package | Version | License | Why it is there |
| --- | --- | --- | --- |
| `pywin32` | 312 | PSF-2.0 | Reaches Roche’s LIMS interface, a Windows COM server. Carried by the LightCycler 480 component, which every installation includes. |

### Embedded runtimes

Each executable carries its own Python, with its own OpenSSL, which encrypts the connections. The cryptography library brings a second OpenSSL, for the key signatures. The LightCycler 480 component carries a 32-bit Python of its own. None of these shows in a list of Python packages; a scan of the installer finds all of them, Shawl and the PyInstaller bootloader too.

| Package | Version | License | Why it is there |
| --- | --- | --- | --- |
| `CPython` | 3.14.9 (64-bit) | PSF-2.0 | The agent’s own runtime. |
| `CPython` | 3.11.9 (32-bit) | PSF-2.0 | A second runtime, carried only by the LightCycler 480 component. Roche’s COM interface is registered 32-bit only, so that component is a separate 32-bit executable; the core agent stays 64-bit. |
| `OpenSSL (in each Python)` |  | Apache-2.0 | Encrypts the connections to Clarida. |
| `OpenSSL (in cryptography)` |  | Apache-2.0 | Signs with the agent’s Ed25519 key. |
| `Shawl` | 1.9.0 | MIT | Runs the agent as a Windows service. |
| `PyInstaller bootloader` | 6.22.3 | GPL-2.0-or-later with the bootloader exception | Starts each executable. |

### Shipped, not used by Porta

The build freezes its development environment, so two packages Porta never imports ship too.

| Package | Version | License | Why it is there |
| --- | --- | --- | --- |
| `Pillow` | 13.0.0 | MIT-CMU | Pulled in by the build; Porta does not use them. |
| `Pygments` | 2.21.0 | BSD-2-Clause | Pulled in by the build; Porta does not use them. |

Read from the release build of October 29, 2026, Porta 0.3.1. Versions advance with releases. For a current listing against a specific build, ask us.

## 10. Questions for your review

Reviewing Porta for your institution and need more, such as a questionnaire filled in or a listing against a specific build? Write to [info@clarida.bio](mailto:info@clarida.bio). A founder answers within a working day. How we handle personal data is in our [privacy policy](https://clarida.bio/privacy).
