Integrity
Signed updates and license: know exactly what runs
The platform is delivered compiled, each release is signed and checked at installation, and a single license is checked by each component. Here is how it works.
Contents
Installing software on your servers means agreeing to run code written by others there. The legitimate question from your security team is therefore: how do you know that what runs is exactly what was delivered, and nothing else? This page describes the three mechanisms that answer it: compiled delivery, release signing and the license.
A compiled delivery
The platform is delivered compiled, as containers ready to install. Your teams do not have to assemble components or fetch dependencies at installation time: what is delivered forms a consistent whole, identified by a version number.
This form of delivery also protects our work: the code is not distributed in clear. It changes nothing about your control over execution: the containers run on your servers, under your monitoring.
Signed releases, checked by the installer
Each release is signed. The signature is checked at installation, then at each start launched by the installation script: a release modified after its publication, even slightly, fails this check and does not start. An automatic restart of the containers, for example after a server reboot, does not repeat this check.
We publish a release
The release is built then signed; it carries a unique number.
You receive it
The transfer method is agreed with you: it can be adapted to an installation without Internet access.
The installation checks the signature
If the signature does not match, the installation stops. Nothing is started.
The platform starts
The installed release is visible from the interface, which lets you check what is actually running.
A single license, checked by each component
A single license covers your installation. It is not checked in one place only: each component checks it at startup. Without a valid license, nothing starts.
This choice has two effects. First, an isolated component cannot be extracted and run elsewhere without a license. Second, the license status is unambiguous: either the installation is covered and works, or it does not start.
The license is checked on site: checking it requires no call to an online service. Its scope, duration and renewal are defined in the quote; purchase is on quote only.
What the signature and the license do not do
These mechanisms protect the integrity of what is delivered and govern its use. They send nothing outside: the signature check and the license check are done on your servers, without calling an online service. Nor do they replace your own controls: server hardening, network filtering, monitoring and backups remain your responsibility, as for any application installed on your infrastructure. Finally, they do not block access to your data: at the end of the license, the data stored on your servers remains yours.
How an update works
An update follows the same path as a first installation: receipt of a signed release, signature check, startup. The detailed procedure, the schedule and how to roll back to the previous release if needed are to be specified as part of the project, with your operations teams.
A few principles we recommend:
- Back up the data before each update (see Continuity and backup).
- Test the new release on a separate environment before production.
- Record the installed release and its date in your change register.
Security fixes
When a vulnerability is fixed, the fix is distributed the same way: a new signed release. There is no parallel channel, and no hot modification of the containers. How reports are handled is described on the page Vulnerability management.