> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cockroachlabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Install a FIPS-ready CockroachDB Runtime

export const InternalLink = ({version, path = "", children, ...props}) => {
  let detectedVersion = version || "stable";
  if (typeof window !== 'undefined' && !version) {
    const match = window.location.pathname.match(/\/docs\/([^/]+)/);
    if (match) {
      detectedVersion = match[1];
    }
  }
  const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
  return <a href={`/docs/${detectedVersion}/${normalizedPath}`} {...props}>
      {children}
    </a>;
};

<Note>
  **What "FIPS support" means**

  When CockroachDB documentation refers to "FIPS support" or "FIPS-ready" deployments, this means CockroachDB can be configured to use FIPS 140-3-approved cryptographic algorithms and operate in accordance with a FIPS 140-3 cryptographic module's Security Policy. It does not mean that CockroachDB itself is FIPS 140-3 validated.

  CockroachDB uses the frozen Go Cryptographic Module v1.0.0, which is FIPS 140-3 validated under <a href="https://csrc.nist.gov/projects/cryptographic-module-validation-program/certificate/5247">CMVP Certificate #5247</a>.
</Note>

## Overview of FIPS-ready CockroachDB

[Federal Information Processing Standards (FIPS) 140-3](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.140-3.pdf) is a U.S. government standard that specifies security requirements for cryptographic modules. FIPS 140-3 provides measurable security guidelines for protecting sensitive but unclassified information. The standard is applicable to all federal agencies that use cryptographic-based security systems to protect sensitive information in computer and telecommunication systems. U.S. and Canadian governments, as well as organizations working with them, may be subject to FIPS 140-3 requirements.

The Cryptographic Module Validation Program (CMVP) validates cryptographic modules to FIPS 140-3 and other cryptography-based standards. When a cryptographic module or library has a FIPS 140-3 certificate, it has been tested and formally validated under the CMVP as meeting the requirements for FIPS 140-3.

FIPS-ready CockroachDB binaries and Docker images are available for CockroachDB v23.1.0 and later. FIPS-ready CockroachDB runtimes run on Intel 64-bit Linux systems.

Starting with v26.1, FIPS-ready CockroachDB binaries are built using Go's native FIPS 140-3 support. The cryptographic operations are performed by Go's built-in cryptographic modules, which are independent of the host operating system's libraries. This represents a significant architectural change from previous versions (v25.4 and earlier), which used Red Hat's golang-fips toolchain with OpenSSL.

<Note>
  **Migration from FIPS 140-2 to FIPS 140-3**

  Previous versions of CockroachDB (v25.4 and earlier) supported FIPS 140-2. Starting with v26.1, CockroachDB uses a cryptographic module designed for FIPS 140-3 support. Starting with v26.2, CockroachDB uses `GOFIPS140=v1.0.0`, the frozen module version that is FIPS 140-3 validated under <a href="https://csrc.nist.gov/projects/cryptographic-module-validation-program/certificate/5247">CMVP Certificate #5247</a>.

  FIPS 140-2 will transition to historical status on September 22, 2026, per [NIST's FIPS 140-3 Transition Effort](https://csrc.nist.gov/Projects/fips-140-3-transition-effort).
</Note>

For details about cryptographic algorithms and key lengths used by CockroachDB, refer to [Details About Cryptographic Algorithms](#details-about-cryptographic-algorithms).

### FIPS-ready features

When you use a FIPS-ready CockroachDB runtime, Cockroach Labs has verified that cryptographic operations in the following contexts meet the requirements of FIPS 140-3:

* <InternalLink path="security-reference/encryption">Encryption At Rest</InternalLink>
* <InternalLink path="take-and-restore-encrypted-backups">Encrypted Backups</InternalLink>
* <InternalLink path="create-changefeed#query-parameters">Change Data Capture to Kafka over TLS</InternalLink>
* <InternalLink path="authentication">Certificate-based Node-to-Node and Client-to-Node Authentication</InternalLink>
* <InternalLink path="security-reference/scram-authentication">SASL SCRAM-SHA-256 Password Authentication</InternalLink>
* <InternalLink path="functions-and-operators#cryptographic-functions">SQL Cryptographic Built-in Functions</InternalLink>

<Danger>
  When running a FIPS-ready runtime, Cockroach Labs recommends that you avoid using cryptographic operations that are not supported by FIPS 140-3. For example, generating an MD5 hash is not compatible with FIPS 140-3, because MD5 is not a FIPS-validated algorithm. Use algorithms and functions that do not comply with the standard at your own risk.
</Danger>

This page shows how to install and configure a FIPS-ready CockroachDB runtime using Go's native FIPS 140-3 support.

### Performance considerations

When comparing performance of the same workload in a FIPS-ready CockroachDB runtime to a standard CockroachDB runtime, some performance difference may be observed. The amount of performance impact depends upon the workload, cluster configuration, query load, and other factors.

### Upgrading to a FIPS-ready CockroachDB runtime

Upgrading an existing CockroachDB cluster's binaries in-place to be FIPS-ready is not supported.

## Operating system requirements

FIPS-ready CockroachDB uses Go's native cryptographic module, which is independent of the host operating system's libraries. The FIPS-ready binary can run on any Intel 64-bit Linux system.

The FIPS-ready CockroachDB Docker images are based on [Red Hat's Universal Base Image 10](https://catalog.redhat.com/software/containers/ubi10/ubi-minimal/). To [use the FIPS-ready CockroachDB Docker image](#use-the-fips-ready-cockroachdb-docker-image), skip directly to that section of this page.

### Extend Red Hat's Universal Base Image 10 Docker image

If you do not want to use the FIPS-ready CockroachDB Docker image directly, you can create a custom Docker image based on [Red Hat's Universal Base Image 10](https://catalog.redhat.com/software/containers/ubi10/ubi-minimal/):

* The FIPS-ready binary includes the FIPS 140-3 Go Cryptographic Module and does not require additional system libraries to be installed.

<a id="downloads" />

## Download FIPS-ready runtimes

FIPS-ready runtimes are not yet available for CockroachDB v26.3. Download links will be added when v26.3.0 becomes available for self-hosted deployments.

<a id="install" />

## Install the FIPS-ready CockroachDB runtime

When FIPS-ready CockroachDB v26.3 binaries become available, install them in the same way as standard binaries. Refer to <InternalLink path="install-cockroachdb-linux">Install CockroachDB on Linux</InternalLink>.

<Note>
  **Upgrade from v25.4 or v26.1 FIPS to v26.2 or later**

  CockroachDB v26.1 and later use Go's native FIPS cryptographic module, a significant architectural change from the OpenSSL-based approach used in v25.4 and earlier. FIPS support was Preview in v26.1, so deployments using FIPS on v25.4 or v26.1 should upgrade to v26.2 or a later version.

  Upgrading an existing CockroachDB cluster's binary in-place from non-FIPS to FIPS is not supported. Instead, you can <InternalLink path="restore#full-cluster">restore your cluster</InternalLink> to a new FIPS-ready cluster.
</Note>

### Verify that CockroachDB is FIPS-ready

To verify that the CockroachDB binary is FIPS-ready, use the `cockroach version` command and check for the `FIPS enabled` field:

```shell theme={"theme":{"light":"catppuccin-mocha","dark":"catppuccin-mocha"}}
cockroach version | grep -i fips
```

```shell theme={"theme":{"light":"catppuccin-mocha","dark":"catppuccin-mocha"}}
FIPS enabled: true
```

This indicates that CockroachDB was built with Go's native FIPS 140-3 support.

<Note>
  **Change from previous versions:** In v25.4 and earlier, FIPS-ready binaries showed `fips` appended to the Go version (e.g., `go1.19.5fips`). Starting with v26.1, FIPS status is indicated by the `FIPS enabled: true` field.
</Note>

## Use the FIPS-ready CockroachDB Docker image

FIPS-ready CockroachDB Docker images are not yet available for CockroachDB v26.3. Image tags and usage instructions will be added when v26.3.0 becomes available for self-hosted deployments.

## Details about cryptographic algorithms

This section provides more information about the cryptographic algorithms and key lengths used by FIPS-ready CockroachDB.

### Authentication

#### Inter-node and node identity

**Algorithm**: [TLS 1.3 (RFC 8446)](https://www.rfc-editor.org/rfc/rfc8446).

Refer to <InternalLink path="authentication#using-digital-certificates-with-cockroachdb">Using Digital Certificates with CockroachDB</InternalLink>.

#### Client identity

<a id="password-authentication" />

##### Password authentication

**Algorithm**: `bcrypt` or `scram-sha-256`.

Refer to <InternalLink path="security-reference/scram-authentication">SASL/SCRAM-SHA-256 Secure Password-based Authentication</InternalLink>.

<a id="client-certificates" />

##### Client certificates

**Algorithm**: [TLS 1.3 (RFC 8446)](https://www.rfc-editor.org/rfc/rfc8446).

Refer to <InternalLink path="authentication#using-digital-certificates-with-cockroachdb">Using Digital Certificates with CockroachDB</InternalLink>.

<a id="gssapi-/-kerberos" />

##### GSSAPI / Kerberos

Not supported for FIPS-ready deployments.

<a id="sasl-/-scram-password-authentication" />

##### SASL / SCRAM password authentication

**Algorithm**: `scram-sha-256`.

Refer to <InternalLink path="security-reference/scram-authentication">SASL/SCRAM-SHA-256 Secure Password-based Authentication</InternalLink>.

<a id="json-web-tokens-jwts" />

##### JSON Web Tokens (JWTs)

**Algorithms**: Specified by the <InternalLink path="sso-sql#cluster-settings">`server.jwt_authentication.jwks` cluster setting</InternalLink>.

Refer to <InternalLink path="sso-sql">Cluster Single Sign-on (SSO) using a JSON web token (JWT)</InternalLink>.

<a id="db-console-authentication-via-oidc" />

##### DB Console authentication via OIDC

**Algorithm**: Specified by the identity provider (IdP) as part of the OIDC handshake process.

Refer to <InternalLink path="sso-db-console">Single Sign-on (SSO) for DB Console</InternalLink>.

<a id="http-api-access-via-login-tokens" />

##### HTTP API access via login tokens

**Algorithm**: `sha256` ([RFC 6234](https://datatracker.ietf.org/doc/html/rfc6234)).

### Encryption

#### In flight

**Algorithm**: [TLS 1.3 (RFC 8446)](https://www.rfc-editor.org/rfc/rfc8446).

**Key sizes**: Depends upon the cipher suite in use:

* TLS 1.2:
  * `tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256`
  * `tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384`
  * `tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256`
  * `tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384`
  * If the `COCKROACH_TLS_ENABLE_OLD_CIPHER_SUITES` environment variable is set:

    * `tls.TLS_RSA_WITH_AES_128_GCM_SHA256`
    * `tls.TLS_RSA_WITH_AES_256_GCM_SHA384`

* TLS 1.3:
  * `TLS_AES_128_GCM_SHA256`
  * `TLS_AES_256_GCM_SHA384`

#### At rest

<a id="customer-managed-backups" />

##### Customer-managed backups

<a id="aws" />

##### AWS

Default encryption provided by the [AWS Encryption SDK](https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/introduction.html).

<a id="gcp" />

##### GCP

Default encryption provided by [Google Cloud](https://cloud.google.com/docs/security/encryption/default-encryption).

<a id="data-encryption-at-rest-ear" />

##### Data Encryption at Rest (EAR)

**Algorithm**: Advanced Encryption Standard (AES) encryption, in counter (CTR) mode.

**Key sizes**: The store key is specified by the user, and can be of length 16, 24, or 32 bytes (corresponding to AES-128, AES-192, or AES-256). Data keys are the same length as the store key.

## See also

* <InternalLink path="install-cockroachdb-linux">Install CockroachDB</InternalLink>
* <InternalLink version="releases" path="index">Releases</InternalLink>