Authentification unique avec OpenBao

Cette section explique comment activer l’authentification unique (SSO) dans Parsec via OpenBao, un gestionnaire de secrets open source issu de la communauté OpenSSF de la Linux Foundation.

Présentation

Parsec prend en charge l’authentification unique (SSO) via un serveur OpenBao connecté à un fournisseur d’identité OIDC (OpenID Connect). Cette intégration répond aux objectifs suivants :

Authentification des utilisateurs & Protection de l’appareil

Parsec stocke les clés cryptographiques sur l’ordinateur de l’utilisateur. Ces clés sont protégées par différents mécanismes selon la méthode d’authentification sélectionnée.

Avec le SSO, les clés sont chiffrées à l’aide de l’identité SSO de l’utilisateur. Ainsi, un pirate qui parviendrait à dérober le fichier de clés ne pourrait pas le déchiffrer sans contrôler également le compte SSO de l’utilisateur.

Enrôlement asynchrone

Lorsqu’un nouvel utilisateur souhaite rejoindre une organisation Parsec, il passe généralement par un enrôlement synchrone : c’est-à-dire que le nouvel utilisateur et l’administrateur de l’organisation doivent être en ligne en même temps et échanger des codes pour valider mutuellement leur identité.

Avec SSO, l’identité est fournie pour les deux parties, ce qui signifie que l’inscription peut se faire de manière asynchrone : l’utilisateur envoie une demande pour rejoindre l’organisation, et l’administrateur approuve (ou rejette) cette demande ultérieurement (aucune présence simultanée n’est requise).

Note

Seulement ProConnect OIDC est supporté pour le moment.

Sécurité

Le niveau de sécurité lié au stockage des clés opaques dans OpenBao est inférieur à celui des méthodes traditionnelles, telles que le stockage des clés dans le keyring du système d’exploitation ou leur dérivation à partir d’un mot de passe fort.

En revanche, si vos utilisateurs connaissent déjà l’authentification unique (SSO) et l’utilisent pour d’autres services, ils disposent probablement déjà d’un compte, ce qui simplifiera considérablement à la fois la connexion à Parsec et l’enrôlement de nouveaux utilisateurs.

Il s’agit donc d’un compromis classique entre sécurité et simplicité d’utilisation ; la décision d’utiliser ou non cette méthode doit être prise par l’administrateur du serveur et doit être cohérente avec votre propre modèle de menaces.

Architecture

flowchart TD oip[OpenID Provider] bao[OpenBao Server] client[Parsec Client] server[Parsec Server] oip --(1) OIDC authentication (login / token) ---> client client --(2) Sign join request or (d)encrypt device keys---> bao client --(3) Submit signed join request---> server

  1. Le client Parsec authentifie l’utilisateur auprès d’un fournisseur OpenID (tel qu’un SSO d’entreprise ou du gouvernement). OpenBao est configuré pour faire confiance à ce fournisseur ; le token ainsi obtenu est donc utilisable sur OpenBao.

  2. Le client Parsec utilise le token pour appeler OpenBao afin de :

    • Stocker ou récupérer les clés chiffrées de l’appareil (cas d’utilisation « Protection de l’appareil »), ou

    • Signer / vérifier une payload d’enrôlement à l’aide de la clé de transit par entité de l’utilisateur (cas d’utilisation « Enrôlement asynchrone »).

  3. Dans le cas d’un enrôlement asynchrone, la demande d’enrôlement signée est ensuite envoyée au serveur Parsec, afin que l’administrateur de l’organisation puisse la récupérer ultérieurement (celui-ci pourra alors vérifier sa signature à l’aide d’OpenBao).

Prérequis

  • Une instance OpenBao déployée et accessible à la fois par les utilisateurs et par le serveur Parsec.

  • Un fournisseur d’identité compatible OIDC

  • L’outil bao pour configurer OpenBao.

Configuration du fournisseur d’identité OIDC

L’authentification OIDC fonctionne en transmettant un token au client via une redirection HTTP initiée par le fournisseur d’identité.

Pour cela, le fournisseur d’identité OIDC doit être configuré avec deux URL de redirection :

  • Pour le web, l’URL est https://<your-parsec-server>/client/oidc/callback.

  • Pour le client natif, l’URL est toujours https://callback.parsec.cloud.invalid/oidc/callback.

Note

Le client natif ne requête en réalité jamais l’URL de redirection (ce qui est impossible de toute façon, car il s’agit d’un TLD .invalid). À la place, ce nom de domaine spécial est détecté par le client pour empêcher la redirection et extraire directement le token d’authentification de l’URL.

Configuration OpenBao

Les étapes suivantes sont nécessaires pour configurer OpenBao afin d’activer l’authentification unique (SSO) dans Parsec.

Avant de commencer, assurez-vous de définir les variables d’environnement suivantes :

  • BAO_ADDR : l’URL de votre instance OpenBao

  • BAO_TOKEN : le token root pour s’authentifier auprès de l’instance OpenBao

Par exemple :

export BAO_ADDR=https://openbao.example.com
export BAO_TOKEN=s.raPGTZdARXdY0KvHcWSpp5wWZIHNT

Activer les moteurs de secrets requis

# Transit engine — used to sign/verify enrollment payloads
bao secrets enable -path=transit transit

# KV v2 engine — used to store encrypted device key files
bao secrets enable -path=secret kv-v2

Activer et configurer la méthode d’authentification OIDC

Le chemin <parsec_oidc> est utilisé ci-dessous pour la méthode d’authentification OIDC. Si vous le souhaitez, vous pouvez indiquer un autre chemin de montage.

Utilisez les identifiants de votre client pour remplacer <your-client-id> et chargez le secret à partir d’un fichier client-secret.txt afin qu’il n’apparaisse pas dans la ligne de commande et qu’il ne soit pas enregistré dans l’historique du shell.

# Enable the OIDC auth method at path "<parsec_oidc>"
bao auth enable -path=<parsec_oidc> oidc

# Point it at your identity provider and set the client credentials
bao write auth/<parsec_oidc>/config \
    oidc_discovery_url="https://<parsec_oidc>.example.com/login" \
    oidc_client_id="<your-client-id>" \
    oidc_client_secret=@client-secret.txt \
    default_role="default"

Configurer le rôle OIDC

Ce rôle établit une correspondance entre un champ du token OIDC et l’entité OpenBao. Parsec utilise la revendication email pour identifier les utilisateurs, afin que le processus d’enrôlement puisse vérifier que l’adresse e-mail figurant dans la charge utile d’enrôlement correspond bien à celle de l’utilisateur authentifié.

bao write auth/<parsec_oidc>/role/default \
    user_claim="email" \
    allowed_redirect_uris="https://<your-parsec-server>/client/oidc/callback" \
    allowed_redirect_uris="https://callback.parsec.cloud.invalid/oidc/callback" \
    token_policies="parsec-default"

Note

La variable allowed_redirect_uris doit inclure toutes les URI de redirection que le client Parsec utilisera. Consultez la documentation de déploiement d’OpenBao pour connaître les valeurs exactes.

Politique relative à l’ACL

Afin de définir la politique ACL, créez un fichier parsec-default.hcl avec le contenu suivant :

parsec-default.hcl 
 1# -------------------------------------------------------------------------
 2# Token self-management
 3# -------------------------------------------------------------------------
 4
 5# Allow tokens to look up their own properties
 6path "auth/token/lookup-self" {
 7    capabilities = ["read"]
 8}
 9
10# Allow tokens to renew themselves
11path "auth/token/renew-self" {
12    capabilities = ["update"]
13}
14
15# Allow tokens to revoke themselves
16path "auth/token/revoke-self" {
17    capabilities = ["update"]
18}
19
20# Allow a token to look up its own entity by id or name
21path "identity/entity/id/{{identity.entity.id}}" {
22    capabilities = ["read"]
23}
24path "identity/entity/name/{{identity.entity.name}}" {
25    capabilities = ["read"]
26}
27
28# Allow a token to look up its resultant ACL from all policies
29path "sys/internal/ui/resultant-acl" {
30    capabilities = ["read"]
31}
32
33# Allow a token to make requests to the Authorization Endpoint for OIDC providers
34path "identity/oidc/provider/+/authorize" {
35    capabilities = ["read", "update"]
36}
37
38# -------------------------------------------------------------------------
39# Parsec per-entity device key store
40# (used to protect device files stored on the user's machine)
41# -------------------------------------------------------------------------
42
43# Allow an entity to store its own device keys
44path "secret/data/{{identity.entity.id}}/*" {
45    capabilities = ["create", "update", "patch", "read", "delete"]
46}
47path "secret/metadata/{{identity.entity.id}}/*" {
48    capabilities = ["read", "list", "delete"]
49}
50
51# -------------------------------------------------------------------------
52# Parsec entity-to-entity authenticated message passing
53# (used to sign and verify asynchronous enrollment payloads)
54# -------------------------------------------------------------------------
55
56# User creates its own signing key in the transit engine
57path "transit/keys/entity-{{identity.entity.id}}" {
58    capabilities = ["update"]
59}
60
61# User signs a message with its own key
62path "transit/sign/entity-{{identity.entity.id}}" {
63    capabilities = ["update"]
64}
65
66# Any user can read another entity's metadata (to retrieve its email)
67path "identity/entity/id/*" {
68    capabilities = ["read"]
69}
70
71# Any user can verify a signature made by another entity
72path "transit/verify/entity-*" {
73    capabilities = ["update"]
74}

Appliquez-la :

bao policy write parsec-default parsec-default.hcl

Vérifiez la configuration

# Log in as a test user
bao login -method=oidc -path=<parsec_oidc>

# Confirm the token has the expected capabilities:
bao token capabilities \
transit/sign/entity-$(bao token lookup -format=json | jq -r '.data.entity_id')

Configurer CORS

bao write sys/config/cors allowed_origins='https://<your-parsec-server>' allowed_origins='parsec-desktop://-'

Note

Le domaine parsec-desktop://- est utilisé par le client natif Parsec.

Vous pouvez vérifier que CORS est correctement configuré pour votre domaine avec la commande suivante :

curl -v -X OPTIONS https://<your-openbao-server>/v1/auth/<parsec_oidc>/oidc/auth_url \
      -H "Origin: https://<your-parsec-server>" \
      -H "Access-Control-Request-Method: GET"

Configuration du serveur Parsec

Une fois le serveur OpenBao installé, vous devrez configurer votre serveur Parsec.

En suivant la même procédure que lors du déploiement, créez un fichier pour enregistrer les variables d’environnement requises (saisissez la valeur OPENBAO_SERVER_URL indiquée précédemment) :

parsec-openbao.env 
# URL of the OpenBao server to allow SSO (OIDC) authentication in Parsec.
#
# Parsec will store opaque keys that are used to encrypt local device keys.
PARSEC_OPENBAO_SERVER_URL=<YOUR_OPENBAO_SERVER_URL>

# Mount path of the OpenBao KV2 secret module used for storage
PARSEC_OPENBAO_SECRET_MOUNT_PATH=secret

# Mount path of the OpenBao transit module
PARSEC_OPENBAO_TRANSIT_MOUNT_PATH=transit

# Mount path of the OpenBao auth module for end-user authentication using
# OIDC with ProConnect
PARSEC_OPENBAO_AUTH_PRO_CONNECT_MOUNT_PATH=parsec_oidc

Parsec Server avec Docker

Si vous avez déployé Parsec Server avec Docker, modifiez le fichier Docker Compose pour y ajouter parsec-openbao.env :

parsec-server.docker.yaml 
    env_file:
      - parsec.env
      - parsec-s3.env
      - parsec-db.env
      - parsec-smtp.env
      - parsec-admin-token.env
      - parsec-openbao.env

Puis redémarrez le serveur.

Parsec Server sous Linux

Si vous avez déployé Parsec Server directement sous Linux, modifiez votre script d’exécution pour y ajouter « parsec-openbao.env » :

run-parsec-server 
# Load the virtual env
source venv/bin/activate

# Load the env files into the environment table
set -a
source parsec-openbao.env
source parsec-admin-token.env
source parsec-db.env
source parsec-smtp.env
source parsec-s3.env
source parsec.env
set +a

# Start Parsec Server
python -m parsec run

Puis redémarrez le serveur.