---
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.

Before the installer 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 that they download. They do not check the cosign
signatures. Do that check yourself, with 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.

## Verify the installer

1. **Download the files**

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

    ```bash
    tag=<tag>
    for f in timescale-enterprise.sh SHA256SUMS 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`.

3. **Run the installer**

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

The `curl ... | sh` command of [The installer menu](/docs/v2026.11.7-beta/installation#the-installer-menu) runs the
installer with no check. To check the installer, use the steps above.

### 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
[Verify the installer](#verify-the-installer), 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.7-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
[Verify the installer](#verify-the-installer), 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. **Verify the installer**

    Follow [Verify the installer](#verify-the-installer). Use that installer to make the
    package.

2. **Make the package**

    Follow [Make the offline/airgapped package](/docs/v2026.11.7-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
    [Verify the installer](#verify-the-installer). 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>`.
