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.

Pour utiliser Key Connector, vous devez :

• Avoir une organisation d'entreprise .

• Avoir un serveur Bitwarden auto-hébergé .

• Avoir une implémentation active du SSO .

• Activez les stratégies Organisation unique et Exiger une authentification unique .

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.

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.

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.

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 :

   BashCopy
   ./bitwarden.sh update

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

   BashCopy
   nano bwdata/config.yml

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

   BashCopy
   ./bitwarden.sh rebuild

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

   BashCopy
   ./bitwarden.sh update

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.

   BashCopy
   nano bwdata/env/key-connector.override.env

   avertissement

   Ce fichier sera pré-rempli avec des valeurs par défaut qui mettront en place une configuration locale fonctionnelle de Key Connector, cependant les valeurs par défaut ne sont pas recommandées pour les environnements de production.

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 :

BashCopy
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 :

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.

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 :

BashCopy
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}

BashCopy
keyConnectorSettings__rsaKey__provider=certificate
keyConnectorSettings__certificate__provider=filesystem
keyConnectorSettings__certificate__filesystemPath={Certificate_Path}
keyConnectorSettings__certificate__filesystemPassword={Certificate_Password}

BashCopy
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}

BashCopy
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}

BashCopy
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}

BashCopy
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}

BashCopy
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}

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

BashCopy
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}

OPTIONALLY:
keyConnectorSettings__rsaKey__pkcsLibraryPath={path/to/library/file}

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 :

   BashCopy
   ./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

   Les prochaines étapes supposent que vous avez déjà un identifiant avec une mise en œuvre SSO active utilisant SAML 2.0 ou OIDC. Si ce n'est pas le cas , veuillez implémenter et tester la connexion avec SSO avant de continuer.

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.