---
title: Verify a release
description: "Check the signatures and the checksums of the installer, the console image, the server packages and an offline/airgapped package of a release."
sidebar:
  icon: shield-check
search:
  keywords: ["verify", "signature", "cosign", "sigstore", "ssh-keygen", "SHA256SUMS.sig", "checksum", "SHA256SUMS", "SBOM", "provenance", "supply chain"]
seo:
  title: "Verify release signatures"
---

Each release of TimescaleDB Enterprise is signed. Use this page to check the files of a
release before you install them.

The installer checks the release files that it downloads or loads, with no action from you. Before it uses
`SHA256SUMS`, it checks the signature of `SHA256SUMS` with the
[release signing key](#the-release-signing-key) in the installer. Then the installer and the
console check the sha256 of each file against `SHA256SUMS`. The installer shows each passed
check, for example `Verify the release signature of SHA256SUMS (key SHA256:KPeH3iPAZm19lBI...)`
and `Verify the files against SHA256SUMS (3 of 3)`. The key is the start of the
[release signing key's](#the-release-signing-key) fingerprint.

The installer and the console do not check the cosign signatures. To check them, or to check
the installer itself, use the commands on this page.

## What the release signs

The release workflow of TimescaleDB Enterprise runs on GitHub Actions. It signs with Sigstore
keyless signing (cosign): GitHub Actions gives the workflow an OIDC identity token, and the
Sigstore certificate authority (Fulcio) issues a short-lived certificate for that identity.
The certificate names the workflow and the release tag. The Sigstore transparency log records
each signature. No long-lived key makes the cosign signatures.

The release also signs `SHA256SUMS` with the [release signing key](#the-release-signing-key),
an Ed25519 key, into `SHA256SUMS.sig` (`ssh-keygen -Y sign`). The installer checks this
signature.

| File | Where | What protects it |
| --- | --- | --- |
| `SHA256SUMS` | `https://enterprise.tigerdata.com/install/<tag>/` and the release artifact | A cosign signature, in `SHA256SUMS.cosign.bundle`, and a signature of the release signing key, in `SHA256SUMS.sig` |
| The installer, `timescale-enterprise.sh` | `https://enterprise.tigerdata.com/install/<tag>/` and the release artifact | Its line in `SHA256SUMS` |
| The console bundles and their SBOM files | The release artifact | Their lines in `SHA256SUMS` |
| The server packages and server components files | The release artifact | Their lines in `SHA256SUMS`, and an OpenPGP signature in each file |
| The public package key, `tse-pack.asc` | `https://enterprise.tigerdata.com/install/<tag>/` and the release artifact | Its line in `SHA256SUMS` |
| The console image, `docker.io/timescale/enterprise` | Docker Hub | A cosign signature on the image index and on each architecture image |

The release artifact is `docker.io/timescale/enterprise-packs:<tag>`. `<tag>` is the release
tag with the `v`, for example `v2026.11.0-beta`.

A valid cosign signature has this certificate identity and this OIDC issuer:

| Field | Value |
| --- | --- |
| Certificate identity | `https://github.com/timescale/enterprise/.github/workflows/release.yml@refs/tags/<tag>` |
| OIDC issuer | `https://token.actions.githubusercontent.com` |

You need these tools:

- [cosign](https://docs.sigstore.dev/cosign/system_config/installation/) 3.0 or later. The
  release signs with cosign 3.
- `sha256sum`. On macOS, use `shasum -a 256` in place of `sha256sum`.
- `ssh-keygen` of OpenSSH 8.1 or later, to check `SHA256SUMS.sig`. macOS has it. On Ubuntu and
  Debian, it is in the package `openssh-client`.
- [oras](https://oras.land/docs/installation), to download the release files other than the
  installer.
- Docker with the buildx plugin, to read the SBOM and the provenance of the console image.

## Check the installer before you run it

This check is optional. It covers the installer file itself, with these steps.

1. **Download the files**

    Set `tag` to the release, then download the installer, `SHA256SUMS` and its signatures:

    ```bash
    tag=<tag>
    for f in timescale-enterprise.sh SHA256SUMS SHA256SUMS.sig SHA256SUMS.cosign.bundle; do
      curl -fsSLO "https://enterprise.tigerdata.com/install/$tag/$f"
    done
    ```

2. **Check the signature and the checksums**

    In the same directory, run:

    ```bash
    cosign verify-blob SHA256SUMS \
      --new-bundle-format --bundle SHA256SUMS.cosign.bundle --offline \
      --certificate-identity "https://github.com/timescale/enterprise/.github/workflows/release.yml@refs/tags/$tag" \
      --certificate-oidc-issuer https://token.actions.githubusercontent.com
    sha256sum -c --ignore-missing SHA256SUMS
    ```

    cosign prints `Verified OK`. cosign 3.1 and later also print that `--new-bundle-format`
    and `--offline` are deprecated. These notices do not change the result.
    `sha256sum` prints `OK` for each file of `SHA256SUMS` that
    is in the directory. `--ignore-missing` skips the other files, so make sure that each file
    that you need shows `OK`.

    Without cosign, check `SHA256SUMS.sig` with the
    [release signing key](#the-release-signing-key) and `ssh-keygen` (OpenSSH 8.1 or later)
    instead:

    ```bash
    echo 'timescaledb-enterprise-release namespaces="tse-release" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH+lKegLfPOEDPrwpL0b73mWeDqlTe3Bct/mCOdQlkJb' >allowed_signers
    ssh-keygen -Y verify -f allowed_signers -I timescaledb-enterprise-release -n tse-release \
      -s SHA256SUMS.sig <SHA256SUMS
    sha256sum -c --ignore-missing SHA256SUMS
    ```

    `ssh-keygen` prints `Good "tse-release" signature for timescaledb-enterprise-release with
    ED25519 key SHA256:KPeH3iPAZm19lBI030MQMdw6C5gUQl4NseBiy17m8lU`, and
    `timescale-enterprise.sh` must show `OK`.

3. **Run the installer**

    When both checks pass, run `sh timescale-enterprise.sh`.

The `curl ... | sh` command of [The installer menu](/docs/v2026.11.10-beta/installation#the-installer-menu) runs the
installer of the latest release directly. When you run a downloaded installer file, its banner
shows the first 16 characters of the file's sha256. They match the `timescale-enterprise.sh`
line in `SHA256SUMS`.

### Verify other release files

To check other release files, download them into the same directory, then run the commands of
the step **Check the signature and the checksums** again. Download them with
`oras pull docker.io/timescale/enterprise-packs:<tag>`, or with a tag of this table:

| Tag | Files |
| --- | --- |
| `<tag>` | All files of the release |
| `<tag>-bundle-<arch>` | The console bundle and its SBOM |
| `<tag>-<os>-<version>-<arch>` | The server packages of one OS and architecture |
| `<tag>-components-<arch>` | The server components |

### The release signing key

The release signs `SHA256SUMS` with this Ed25519 key, into `SHA256SUMS.sig`. The installer of
each release has the same key. Before the installer uses `SHA256SUMS` (for an
offline/airgapped package, `--pack`, `--offline` and the installer update), it checks
`SHA256SUMS.sig` with `ssh-keygen -Y verify`. It stops when the signature is not valid or
when `SHA256SUMS.sig` is not there.

| Field | Value |
| --- | --- |
| Type | Ed25519 |
| Fingerprint | `SHA256:KPeH3iPAZm19lBI030MQMdw6C5gUQl4NseBiy17m8lU` |
| Principal | `timescaledb-enterprise-release` |
| Namespace | `tse-release` |

To check `SHA256SUMS.sig` yourself, download it into the directory of
[Check the installer before you run it](#check-the-installer-before-you-run-it), write the key into an allowed signers file,
and check the signature:

```bash
curl -fsSLO "https://enterprise.tigerdata.com/install/$tag/SHA256SUMS.sig"
echo 'timescaledb-enterprise-release namespaces="tse-release" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH+lKegLfPOEDPrwpL0b73mWeDqlTe3Bct/mCOdQlkJb' >allowed_signers
ssh-keygen -Y verify -f allowed_signers -I timescaledb-enterprise-release -n tse-release \
  -s SHA256SUMS.sig <SHA256SUMS
```

`ssh-keygen` prints `Good "tse-release" signature for timescaledb-enterprise-release with
ED25519 key SHA256:KPeH3iPAZm19lBI030MQMdw6C5gUQl4NseBiy17m8lU`.

## Verify the console image

The installer pins the console image by digest. It pulls only that image. From a bundle, it
loads the image of the bundle when the pull fails. Read the pinned image from the installer
that you verified, and check its signature:

```bash
image=$(grep -m1 -o 'docker.io/timescale/enterprise@sha256:[0-9a-f]*' timescale-enterprise.sh)
echo "$image"
cosign verify "$image" \
  --certificate-identity "https://github.com/timescale/enterprise/.github/workflows/release.yml@refs/tags/$tag" \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com
```

The digest is the digest of the image index. The release signs the index and each
architecture image in it, so a pull by either digest verifies.

If you pull or copy the image yourself, use this digest, not a tag. The image tags on Docker
Hub have no `v` (for example `2026.11.0-beta`). A tag can move to another image. A digest
cannot.

### SBOM and provenance

The build attaches an SBOM (SPDX) and SLSA provenance to each architecture image of the
index. Read them from Docker Hub:

```bash
docker buildx imagetools inspect "$image" --format '{{ json (index .SBOM "linux/amd64").SPDX }}'
docker buildx imagetools inspect "$image" --format '{{ json (index .Provenance "linux/amd64").SLSA }}'
```

For an ARM64 host, use `linux/arm64`.

These attestations have no signature of their own. The index names them by digest, so the
cosign signature of the index covers them: verify the image first. The release makes no
cosign attestations, so `cosign verify-attestation` finds nothing.

Each console bundle also has an SBOM file,
`timescale-enterprise-<tag>-console-<arch>.sbom.spdx.json` (tag `<tag>-bundle-<arch>`).
`SHA256SUMS` lists it. It comes from a separate scan of the signed image, so its contents can
differ a little from the SBOM attestation. Use it when you cannot reach Docker Hub.

## Verify the server packages

The [`SHA256SUMS` check](#verify-other-release-files) covers each server packages file and
each server components file. It checks the exact file that the release built.

### What the console checks

Before the console uses a server packages file, it checks:

- The OpenPGP signature of the manifest in the file, with the package key in the console
  image.
- The size and the sha256 of each file in the package against the manifest. The package
  must have no other files.
- The sha256 of the file against `SHA256SUMS` of the release, when the console downloads the
  file. On an upload of a `.tar` file and with `--pack`, the console or the installer checks
  the sha256 when the `.tar` file or the directory has a `SHA256SUMS`. The installer first
  checks `SHA256SUMS.sig` next to it.

A file that fails a check shows **Rejected** in
[Loaded server packages](/docs/v2026.11.10-beta/server-packages#loaded-server-packages). The console does not use
it. The console trusts the server components files of its own image without a signature
check: the signature of the console image covers them.

On each server, a deploy writes the package key to `/etc/tse/pack.asc`. apt checks the
signature of the package repository with that key.

### The package key

| Field | Value |
| --- | --- |
| User ID | `TimescaleDB Enterprise package packs <it@tigerdata.com>` |
| Fingerprint | `AA99 0202 AEC5 1B4D D4ED 952A A039 B7CC 6A40 31D8` |
| Type | RSA 4096 |
| Expires | 2028-10-17 |

Each release publishes the public key as `tse-pack.asc`, next to the installer. The console
image has the same key at `/ansible/files/keys/tse-pack.asc`. To see the keys that a server
trusts, run `gpg --show-keys /etc/tse/pack.asc` on the server. It shows the fingerprint above.

### Check the package signature by hand

You can also do the signature and manifest checks of the console yourself. You need `gpg`,
`jq`, and a `tar` with zstd support. Download the key into the directory of
[Check the installer before you run it](#check-the-installer-before-you-run-it), check it against `SHA256SUMS`, and compare its
fingerprint with [the package key](#the-package-key):

```bash
curl -fsSLO "https://enterprise.tigerdata.com/install/$tag/tse-pack.asc"
sha256sum -c --ignore-missing SHA256SUMS
gpg --show-keys tse-pack.asc
```

`tse-pack.asc` must show `OK`.

Then extract the server packages file, and check the manifest and the files:

```bash
export GNUPGHOME="$(mktemp -d)"
gpg --import tse-pack.asc
mkdir pack
tar --zstd -xf "timescale-enterprise-$tag-server-packages-ubuntu-26.04-amd64.tar.zst" -C pack
cd pack/pack-*
gpg --verify manifest.json.asc manifest.json
jq -r '.files[] | "\(.sha256)  \(.path)"' manifest.json | sha256sum -c --quiet
```

`gpg --verify` prints `Good signature from "TimescaleDB Enterprise package packs <it@tigerdata.com>"`.
It also warns that the key is not certified with a trusted signature. That is normal: the
fingerprint check above takes its place. `sha256sum --quiet` prints nothing when each file
matches. The same steps work for a server components file.

## Verify an offline/airgapped package

The console host of an airgapped install cannot reach Docker Hub or Sigstore. Do the checks on
the computer with internet access, before you copy the package.

1. **Check the installer**

    Follow [Check the installer before you run it](#check-the-installer-before-you-run-it). Use that installer to make the
    package.

2. **Make the package**

    Follow [Make the offline/airgapped package](/docs/v2026.11.10-beta/installation-airgapped#make-the-offlineairgapped-package).

3. **Check the files of the package**

    Extract the package into an empty directory:

    ```bash
    mkdir check
    tar -xf "timescale-enterprise-$tag-offline.tar" -C check
    cd check
    ```

    For a file of `--packs-only`, use `timescale-enterprise-$tag-server-packages.tar`. The
    package has `SHA256SUMS`, `SHA256SUMS.sig` and `SHA256SUMS.cosign.bundle`. In this
    directory, run the commands of the step **Check the signature and the checksums** of
    [Check the installer before you run it](#check-the-installer-before-you-run-it). Each file of the package must show `OK`.
    To also check `SHA256SUMS.sig`, run the `ssh-keygen` commands of
    [The release signing key](#the-release-signing-key) without the `curl` line.

4. **Record the checksum of the package**

    Go back to the directory that holds the package, and run:

    ```bash
    sha256sum "timescale-enterprise-$tag-offline.tar" >offline.sha256
    ```

    Copy `offline.sha256` to the console host with the package. On the console host, run
    `sha256sum -c offline.sha256` before the install.

On the console host, the installer checks `SHA256SUMS.sig` with the
[release signing key](#the-release-signing-key), then checks the console bundle and the server
packages against the `SHA256SUMS` in the package. The console checks the signature of each
server packages file. Neither checks the cosign signature. The console host needs `ssh-keygen`
of OpenSSH 8.1 or later.

On the console host, you cannot check the cosign signature of the console image in the bundle.
The line of the console bundle in `SHA256SUMS` and the signature of `SHA256SUMS` protect it. To read the SBOM and the provenance
of the image, see
[SBOM and provenance](#sbom-and-provenance) on a computer that can reach Docker Hub. The
package does not have the SBOM file. Download it with
`oras pull docker.io/timescale/enterprise-packs:<tag>-bundle-<arch>`.
