Console AdminIdentifiez-vous avec SSO

Déployer Key Connector

Cet article vous guidera à travers la procédure pour activer et configurer Key Connector dans un environnement existant auto-hébergé. Avant de continuer , veuillez lire attentivement l'article à propos de Key Connector pour garantir une compréhension complète de ce qu'est Key Connector, de son fonctionnement et des impacts de sa mise en œuvre.

Bitwarden prend en charge le déploiement d'un Key Connector pour une utilisation par une organisation pour une instance auto-hébergée.

Exigences

avertissement

Management of cryptographic keys is incredibly sensitive and is only recommended for enterprises with a team and infrastructure that can securely support deploying and managing a key server.

Pour utiliser Key Connector, vous devez :

Si votre organisation répond ou peut répondre à ces exigences, y compris une équipe et une infrastructure qui peuvent gérer un serveur clé, contactez-nous et nous activerons Key Connector.

Configurer & déployer Key Connector

Une fois que vous nous aurez contacté concernant Key Connector , nous vous contacterons pour lancer une discussion sur Key Connector. Les étapes qui suivent dans cet article doivent être réalisées en collaboration avec les spécialistes de la réussite client et de la mise en œuvre de Bitwarden.

Obtenir un nouveau fichier de licence

Une fois que vous nous avez contacté concernant Key Connector, un membre de l'équipe de réussite client & mise en œuvre générera un fichier de licence activé par Key Connector pour votre organisation. Lorsque votre collaborateur Bitwarden vous indique qu'il est prêt, suivez les étapes suivantes pour obtenir la nouvelle licence :

  1. Ouvrez l'application web cloud Bitwarden et naviguez vers l'écran Facturation → Abonnement de votre organisation dans la console Admin.

  2. Faites défiler vers le bas et sélectionnez le bouton Télécharger la Licence.

  3. Lorsqu'on vous le demande, entrez l'ID d'installation qui a été utilisé pour installer votre serveur auto-hébergé et sélectionnez Soumettre. Si vous ne connaissez pas votre ID d'installation par cœur, vous pouvez le récupérer à partir de ./bwdata/env/global.override.env.

Vous n'aurez pas besoin de votre fichier de licence immédiatement, mais vous devrez le téléverser sur votre serveur auto-hébergé dans une étape ultérieure.

Initialisez Key Connector

Pour préparer votre serveur Bitwarden pour Key Connector :

  1. Enregistrer une sauvegarde de, au minimum, .bwdata/mssql. Une fois que Key Connector est en utilisation, il est recommandé que vous ayez accès à une image de sauvegarde pré-Key Connector en cas de problème.

    note

    Si vous utilisez une base de données MSSQL externe, faites une sauvegarde de votre base de données de la manière qui convient à votre mise en œuvre.

  2. Mettez à jour votre installation de Bitwarden auto-hébergée afin de récupérer les dernières modifications :

    Bash
    ./bitwarden.sh update

  3. Éditez le fichier .bwdata/config.yml et activez Key Connector en basculant enable_key_connector à true.

    Bash
    nano bwdata/config.yml

  4. Reconstruisez votre installation de Bitwarden auto-hébergée :

    Bash
    ./bitwarden.sh rebuild

  5. Mettez à jour votre installation de Bitwarden auto-hébergée à nouveau afin d'appliquer les modifications :

    Bash
    ./bitwarden.sh update

Configurer Key Connector

Pour configurer Key Connector :

  1. Éditez le fichier .bwdata/env/key-connector.override.env qui aura été téléchargé avec le ./bitwarden.sh mettre à jour.

    Bash
    nano bwdata/env/key-connector.override.env
    avertissement

    This file will be pre-populated with default values that will spin up a functional local Key Connector setup, however the default values are not recommended for production environments.

  2. Dans key-connector.override.env, vous devrez spécifier des valeurs pour les éléments suivants :

    • Points d'extrémité : Avec quels points d'extrémité Bitwarden le Key Connector peut communiquer.

    • Base de données: Où Key Connector stockera et récupérera les clés des utilisateurs.

    • Paire de clés RSA: Comment Key Connector accédera à une paire de clés RSA pour protéger les clés des utilisateurs au repos.

Points finaux

La configuration automatique remplira les valeurs de point de terminaison en fonction de votre configuration d'installation, cependant, il est recommandé de confirmer que les valeurs suivantes dans key-connector.override.env sont précises pour votre configuration :

Bash
keyConnectorSettings__webVaultUri=https://your.bitwarden.domain.com
keyConnectorSettings__identityServerUri=http://identity:5000

Base de données

Key Connector doit accéder à une base de données qui stocke les clés d'utilisateur cryptées pour les membres de votre organisation. Créez une base de données sécurisée pour stocker les clés des utilisateurs cryptées et remplacez les valeurs par défaut de keyConnectorSettings__database__ dans key-connector.override.env par les valeurs indiquées dans la colonne Valeurs Requises pour la base de données choisie :

avertissement

Migration from one database to another is not supported at this time. Regardless of which provider you choose, implement a frequent automated backup schedule for the database.

Base de données

Valeurs requises

JSON local (par défaut)

Non recommandé en dehors des tests.

keyConnectorSettings__database__provider=json

keyConnectorSettings__database__jsonFilePath={File_Path}

Microsoft SQL Server

keyConnectorSettings__database__provider=sqlserver

keyConnectorSettings__database__sqlServerConnectionString={Connection_String}

Apprenez à formater les chaînes de connexion MSSQL

PostgreSQL

keyConnectorSettings__database__provider=postgresql

keyConnectorSettings__database__postgreSqlConnectionString={Connection_String}

Apprenez à formater les chaînes de connexion PostgreSQL

MySQL/MariaDB

keyConnectorSettings__database__provider=mysql

keyConnectorSettings__database__mySqlConnectionString={Connection_String}

Apprenez à formater les chaînes de connexion MySQL

MongoDB

keyConnectorSettings__database__provider=mongo

keyConnectorSettings__database__mongoConnectionString={Connection_String}


keyConnectorSettings__database__mongoDatabaseName={DatabaseName}

Apprenez à formater les chaînes de connexion MongoDB

Paire de clés RSA

Key Connector utilise une paire de clés RSA pour protéger les clés utilisateur au repos. Créez une paire de clés et remplacez les valeurs par défaut keyConnectorSettings__rsaKey__ et keyConnectorSettings__certificate__ dans key-connector.override.env par les valeurs requises pour votre implémentation choisie.

pointe

The RSA key pair must be at a minimum 2048 bits in length.

En général, vos options incluent l'octroi d'un accès Key Connector à un Certificat X509 qui contient la paire de clés ou l'octroi d'un accès Key Connector directement à la Paire de Clés :

To use an X509 certificate that contains an RSA key pair, specify the values required depending on the location where your certificate is stored (see Filesystem, OS Certificate Store, and so on):

pointe

The certificate must be made available as a PKCS12 .pfx file, for example:

Bash
openssl req -x509 -newkey rsa:4096 -sha256 -nodes -keyout bwkc.key -out bwkc.crt -subj "/CN=Bitwarden Key Connector" -days 36500

openssl pkcs12 -export -out ./bwkc.pfx -inkey bwkc.key -in bwkc.crt -passout pass:{Password}

In all certificate implementations, you'll need the CN value shown in this example.

Filesystem (default)

If the certificate is stored on the filesystem of the machine running Key Connector, specify the following values:

note

By default, Key Connector will be configured to create a .pfx file located at etc/bitwarden/key-connector/bwkc.pfx with a generated password. It is not recommended for enterprise implementations to use these defaults.

Bash
keyConnectorSettings__rsaKey__provider=certificate
keyConnectorSettings__certificate__provider=filesystem
keyConnectorSettings__certificate__filesystemPath={Certificate_Path}
keyConnectorSettings__certificate__filesystemPassword={Certificate_Password}

Azure Blob Storage

If the certificate is uploaded to Azure Blob Storage, specify the following values:

Bash
keyConnectorSettings__rsaKey__provider=certificate
keyConnectorSettings__certificate__provider=azurestorage
keyConnectorSettings__certificate__azureStorageConnectionString={Connection_String}
keyConnectorSettings__certificate__azureStorageContainer={Container_Name}
keyConnectorSettings__certificate__azureStorageFileName={File_Name}
keyConnectorSettings__certificate__azureStorageFilePassword={File_Password}

Set azureStorageConnectionString to a Connection string you can generate in your Azure portal from the Shared access signature (SAS) page of your storage account. The SAS must have:

  • Allowed services: Blob and File

  • Allowed resource types: Service, Container, and Object

  • Allowed permissions: Read, Write, and List

  • Allowed blob index permissions: Read/Write and Filter

Azure Key Vault

If certificate is stored in Azure Key Vault, specify the following values:

note

To use Azure Key Vault to store your .pfx certificate, you'll need to create an Active Directory App Registration. This App Registration must:

  • Give delegated API permissions to access Azure Key Vault

  • Have a client secret generated to allow access by Key Connector

Bash
keyConnectorSettings__certificate__provider=azurekv
keyConnectorSettings__certificate__azureKeyvaultUri={Vault_URI}
keyConnectorSettings__certificate__azureKeyvaultCertificateName={Certificate_Name}
keyConnectorSettings__certificate__azureKeyvaultAdTenantId={ActiveDirectory_TenantId}
keyConnectorSettings__certificate__azureKeyvaultAdAppId={AppRegistration_ApplicationId}
keyConnectorSettings__certificate__azureKeyvaultAdSecret={AppRegistration_ClientSecretValue}

Hashicorp Vault

If the certificate is stored in Hashicorp Vault, specify the following values:

note

Key Connector integrates with the Hashicorp Vault KV2 Storage Engine. As per the top of this tab, the certificate file should be in PKCS12 format and stored base64-encoded as the value to a named key in your Vault. If following a Vault tutorial for the KV2 Storage Engine, the key name may be file unless otherwise specified.

Bash
keyConnectorSettings__rsaKey__provider=certificate
keyConnectorSettings__certificate__provider=vault
keyConnectorSettings__certificate__vaultServerUri={Server_URI}
keyConnectorSettings__certificate__vaultToken={Token}
keyConnectorSettings__certificate__vaultSecretMountPoint={Secret_MountPoint}
keyConnectorSettings__certificate__vaultSecretPath={Secret_Path}
keyConnectorSettings__certificate__vaultSecretDataKey={Secret_DataKey}
keyConnectorSettings__certificate__vaultSecretFilePassword={Secret_FilePassword}

To use a cloud provider or physical device to store to a RSA 2048 key pair, specify the values required depending on your chosen implementation (see Azure Key Vault, Google Cloud Key Management, and so on):

Azure Key Vault

If you are using Azure Key Vault to store a RSA 2048 key pair, specify the following values:

note

To use Azure Key Vault to store your RSA 2048 key, you'll need to create an Active Directory App Registration. This App Registration must:

  • Give delegated API permissions to access Azure Key Vault

  • Have a client secret generated to allow access by Key Connector

Bash
keyConnectorSettings__rsaKey__provider=azurekv
keyConnectorSettings__rsaKey__azureKeyvaultUri={Vault_URI}
keyConnectorSettings__rsaKey__azureKeyvaultKeyName={Key_Name}
keyConnectorSettings__rsaKey__azureKeyvaultAdTenantId={ActiveDirectory_TenantId}
keyConnectorSettings__rsaKey__azureKeyvaultAdAppId={AppRegistration_ApplicationId}
keyConnectorSettings__rsaKey__azureKeyvaultAdSecret={AppRegistration_ClientSecretValue}

Learn how to use Azure Key Vault to create a key pair

Google Cloud Key Management

If you are using Google Cloud Key Management to store a RSA 2048 key pair, specify the following values:

Bash
keyConnectorSettings__rsaKey__provider=gcpkms
keyConnectorSettings__rsaKey__googleCloudProjectId={Project_Id}
keyConnectorSettings__rsaKey__googleCloudLocationId={Location_Id}
keyConnectorSettings__rsaKey__googleCloudKeyringId={Keyring_Id}
keyConnectorSettings__rsaKey__googleCloudKeyId={Key_Id}
keyConnectorSettings__rsaKey__googleCloudKeyVersionId={KeyVersionId}

Learn how to use Google Cloud Key Management Service to create key rings and asymmetric keys

AWS Key Management Service

If you are using AWS Key Management Service (KMS) to store a RSA 2048 key pair, specify the following values:

Bash
keyConnectorSettings__rsaKey__provider=awskms
keyConnectorSettings__rsaKey__awsAccessKeyId={AccessKey_Id}
keyConnectorSettings__rsaKey__awsAccessKeySecret={AccessKey_Secret}
keyConnectorSettings__rsaKey__awsRegion={Region_Name}
keyConnectorSettings__rsaKey__awsKeyId={Key_Id}

Learn how to use AWS KMS to create asymmetric keys

PKCS11 Physical HSM

If you are using a physical HSM device with the PKCS11 provider, specify the following values:

Bash
keyConnectorSettings__rsaKey__provider=pkcs11
keyConnectorSettings__rsaKey__pkcs11Provider={Provider}
keyConnectorSettings__rsaKey__pkcs11SlotTokenSerialNumber={Token_SerialNumber}
keyConnectorSettings__rsaKey__pkcs11LoginUserType={Login_UserType}
keyConnectorSettings__rsaKey__pkcs11LoginPin={Login_PIN}

ONE OF THE FOLLOWING TWO:
keyConnectorSettings__rsaKey__pkcs11PrivateKeyLabel={PrivateKeyLabel}
keyConnectorSettings__rsaKey__pkcs11PrivateKeyId={PrivateKeyId}

Where:

  • {Provider} can be yubihsm or opensc

  • {Login_UserType} can be user, so, or context_specific

note

If you are using the PKCS11 provider to store your private key on an HSM device, the associated public key must be made available and configured as a certificate using any of the options found in the Certificates tab.

Activez Key Connector

Maintenant que Key Connector est entièrement configuré et que vous avez une licence activée par Key Connector, suivez les étapes suivantes :

  1. Redémarrez votre installation de Bitwarden auto-hébergée afin d'appliquer les modifications de configuration :

    Bash
    ./bitwarden.sh restart

  2. Connectez-vous à votre Bitwarden auto-hébergé en tant que propriétaire de l'organisation et accédez à l'écran Facturation → Abonnement de la console d'administration.

  3. Sélectionnez le bouton Mettre à jour la licence et téléversez la licence activée par Key Connector récupérée lors d'une étape précédente.

  4. Si vous ne l'avez pas déjà fait, naviguez vers l'écran Paramètres → Politiques de sécurité et activez les politiques Organisation unique et Exiger une authentification unique. Les deux sont nécessaires pour utiliser Key Connector.

  5. Naviguez vers l'écran Paramètres → Authentification unique.

    pointe

    The next few steps assume that you already have an active login with SSO implementation using SAML 2.0 or OIDC. If you don't, please implement and test login with SSO before proceeding.

  6. Dans la section Options de déchiffrement des membres, sélectionnez Key Connector.

  7. Dans l'entrée URL du Key Connector, entrez l'adresse où le Key Connector est en cours d'exécution (par défaut, https://votre.domaine/key-connector) et sélectionnez le bouton Test pour vous assurer que vous pouvez atteindre le Key Connector.

  8. Faites défiler jusqu'en bas de l'écran et sélectionnez Enregistrer.

Faire une suggestion à cette page

Contacter notre équipe de soutien

Pour les questions techniques, de facturation et de produits.

Nom*
Courriel du compte Bitwarden*
Vérifier l'adresse électronique du compte*
Produit*
Êtes-vous un auto-hébergeur ?*
Sujet*
Message...*

État du nuage

Vérifier l'état

© 2024 Bitwarden, Inc. Conditions Confidentialité Paramètres des cookies Plan du site

Go to EnglishStay Here