1. Obtenir les fichiers contenant les certificats de l'autorité de certification au format PEM.
2. Exécutez le script intégré ipa-advise.
3. Recharger la configuration du système.

Procédure

1. Créez un répertoire dans lequel vous effectuerez la configuration :

   [root@server]# mkdir ~/SmartCard/

2. Naviguez jusqu'au répertoire :

   [root@server]# cd ~/SmartCard/

3. Obtenez les certificats d'autorité de certification pertinents stockés dans des fichiers au format PEM. Si votre certificat d'autorité de certification est stocké dans un fichier d'un format différent, tel que DER, convertissez-le au format PEM. Le certificat de l'autorité de certification IdM est au format PEM et se trouve dans le fichier /etc/ipa/ca.crt.

   Convertit un fichier DER en fichier PEM :

   # openssl x509 -in <filename>.der -inform DER -out <filename>.pem -outform PEM

4. Pour plus de commodité, copiez les certificats dans le répertoire dans lequel vous souhaitez effectuer la configuration :

   [root@server SmartCard]# cp /tmp/rootca.pem ~/SmartCard/
   [root@server SmartCard]# cp /tmp/subca.pem ~/SmartCard/
   [root@server SmartCard]# cp /tmp/issuingca.pem ~/SmartCard/

5. En option, si vous utilisez des certificats d'autorités de certification externes, utilisez l'utilitaire openssl x509 pour visualiser le contenu des fichiers au format PEM et vérifier que les valeurs Issuer et Subject sont correctes :

   [root@server SmartCard]# openssl x509 -noout -text -in rootca.pem | more

6. Générer un script de configuration avec l'utilitaire intégré ipa-advise, en utilisant les privilèges de l'administrateur :

   [root@server SmartCard]# kinit admin
   [root@server SmartCard]# ipa-advise config-server-for-smart-card-auth > config-server-for-smart-card-auth.sh

   Le script config-server-for-smart-card-auth.sh effectue les actions suivantes :

   • Il configure le serveur HTTP Apache de l'IdM.
   • Il active la cryptographie à clé publique pour l'authentification initiale dans Kerberos (PKINIT) sur le centre de distribution de clés (KDC).
   • Il configure l'interface Web IdM pour qu'elle accepte les demandes d'autorisation de carte à puce.

7. Exécutez le script en ajoutant les fichiers PEM contenant les certificats de l'autorité de certification racine et de l'autorité de certification secondaire en tant qu'arguments :

   [root@server SmartCard]# chmod +x config-server-for-smart-card-auth.sh
   [root@server SmartCard]# ./config-server-for-smart-card-auth.sh rootca.pem subca.pem issuingca.pem
   Ticket cache:KEYRING:persistent:0:0
   Default principal: admin@IDM.EXAMPLE.COM
   [...]
   Systemwide CA database updated.
   The ipa-certupdate command was successful

   Note

   Assurez-vous que vous ajoutez le certificat de l'autorité de certification racine en tant qu'argument avant tout certificat d'autorité de certification secondaire et que les certificats de l'autorité de certification ou de l'autorité de certification secondaire n'ont pas expiré.

8. En option, si l'autorité de certification qui a émis le certificat utilisateur ne fournit pas de répondeur OCSP (Online Certificate Status Protocol), il peut être nécessaire de désactiver la vérification OCSP pour l'authentification à l'IdM Web UI :

   1. Définissez le paramètre SSLOCSPEnable à off dans le fichier /etc/httpd/conf.d/ssl.conf:

      SSLOCSPEnable off

   2. Redémarrez le démon Apache (httpd) pour que les modifications prennent effet immédiatement :

      [root@server SmartCard]# systemctl restart httpd

   Avertissement

   Ne désactivez pas le contrôle OCSP si vous n'utilisez que des certificats d'utilisateur émis par l'autorité de certification IdM. Les répondeurs OCSP font partie de l'IdM.

   Pour savoir comment maintenir la vérification OCSP activée, tout en empêchant un certificat d'utilisateur d'être rejeté par le serveur IdM s'il ne contient pas les informations relatives à l'emplacement où l'autorité de certification qui a délivré le certificat d'utilisateur écoute les demandes de service OCSP, voir la directive SSLOCSPDefaultResponder dans les options de configuration de Apache mod_ssl.

Procédure

1. Si vos certificats d'autorité de certification sont stockés dans des fichiers d'un format différent, tel que DER, convertissez-les au format PEM:

   # openssl x509 -in <filename>.der -inform DER -out <filename>.pem -outform PEM

   Le certificat de l'autorité de certification IdM est au format PEM et se trouve dans le fichier /etc/ipa/ca.crt.

2. En option, utilisez l'utilitaire openssl x509 pour visualiser le contenu des fichiers au format PEM et vérifier que les valeurs Issuer et Subject sont correctes :

   # openssl x509 -noout -text -in root-ca.pem | more

3. Naviguez jusqu'à votre répertoire ~/MyPlaybooks/ répertoire :

   $ cd ~/MyPlaybooks/

4. Créez un sous-répertoire dédié aux certificats d'autorité de certification :

   $ mkdir SmartCard/

5. Pour plus de commodité, copiez tous les certificats requis dans le répertoire ~/MyPlaybooks/SmartCard/:

   # cp /tmp/root-ca.pem ~/MyPlaybooks/SmartCard/
   # cp /tmp/intermediate-ca.pem ~/MyPlaybooks/SmartCard/
   # cp /etc/ipa/ca.crt ~/MyPlaybooks/SmartCard/ipa-ca.crt

6. Dans votre fichier d'inventaire Ansible, spécifiez ce qui suit :

   • Les serveurs IdM que vous souhaitez configurer pour l'authentification par carte à puce.
   • Le mot de passe de l'administrateur de l'IdM.

   • Les chemins d'accès aux certificats des autorités de certification dans l'ordre suivant :

     • Le fichier du certificat de l'autorité de certification racine
     • Les fichiers des certificats de l'autorité de certification intermédiaire
     • Le fichier du certificat de l'autorité de certification IdM

   Le fichier peut se présenter comme suit :

   [ipaserver]
   ipaserver.idm.example.com
   
   [ipareplicas]
   ipareplica1.idm.example.com
   ipareplica2.idm.example.com
   
   [ipacluster:children]
   ipaserver
   ipareplicas
   
   [ipacluster:vars]
   ipaadmin_password=SomeADMINpassword
   ipasmartcard_server_ca_certs=/home/<user_name>/MyPlaybooks/SmartCard/root-ca.pem,/home/<user_name>/MyPlaybooks/SmartCard/intermediate-ca.pem,/home/<user_name>/MyPlaybooks/SmartCard/ipa-ca.crt

7. Créez un playbook install-smartcard-server.yml avec le contenu suivant :

   ---
   - name: Playbook to set up smart card authentication for an IdM server
     hosts: ipaserver
     become: true
   
     roles:
     - role: ipasmartcard_server
       state: present

8. Enregistrer le fichier.

9. Exécutez le playbook Ansible. Spécifiez le fichier du livre de jeu, le fichier contenant le mot de passe protégeant le fichier secret.yml et le fichier d'inventaire :

   $ ansible-playbook --vault-password-file=password_file -v -i inventory install-smartcard-server.yml

   Le rôle ipasmartcard_server Ansible effectue les actions suivantes :

   • Il configure le serveur HTTP Apache de l'IdM.
   • Il active la cryptographie à clé publique pour l'authentification initiale dans Kerberos (PKINIT) sur le centre de distribution de clés (KDC).
   • Il configure l'interface Web IdM pour qu'elle accepte les demandes d'autorisation de carte à puce.

10. En option, si l'autorité de certification qui a émis le certificat utilisateur ne fournit pas de répondeur OCSP (Online Certificate Status Protocol), il peut être nécessaire de désactiver la vérification OCSP pour l'authentification à l'IdM Web UI :

    1. Se connecter au serveur IdM en tant que root:

       ssh root@ipaserver.idm.example.com

    2. Définissez le paramètre SSLOCSPEnable à off dans le fichier /etc/httpd/conf.d/ssl.conf:

       SSLOCSPEnable off

    3. Redémarrez le démon Apache (httpd) pour que les modifications prennent effet immédiatement :

       # systemctl restart httpd

    Avertissement

    Ne désactivez pas le contrôle OCSP si vous n'utilisez que des certificats d'utilisateur émis par l'autorité de certification IdM. Les répondeurs OCSP font partie de l'IdM.

    Pour savoir comment maintenir la vérification OCSP activée, tout en empêchant un certificat d'utilisateur d'être rejeté par le serveur IdM s'il ne contient pas les informations relatives à l'emplacement où l'autorité de certification qui a délivré le certificat d'utilisateur écoute les demandes de service OCSP, voir la directive SSLOCSPDefaultResponder dans les options de configuration de Apache mod_ssl.

Procédure

1. Sur un serveur IdM, générez un script de configuration avec ipa-advise en utilisant les privilèges de l'administrateur :

   [root@server SmartCard]# kinit admin
   [root@server SmartCard]# ipa-advise config-client-for-smart-card-auth > config-client-for-smart-card-auth.sh

   Le script config-client-for-smart-card-auth.sh effectue les actions suivantes :

   • Il configure le démon de la carte à puce.
   • Il définit la réserve de confiance du système.
   • Il configure le System Security Services Daemon (SSSD) pour permettre aux utilisateurs de s'authentifier soit avec leur nom d'utilisateur et leur mot de passe, soit avec leur carte à puce. Pour plus de détails sur les options du profil SSSD pour l'authentification par carte à puce, voir Options d'authentification par carte à puce dans RHEL.

2. A partir du serveur IdM, copiez le script dans un répertoire de votre choix sur la machine du client IdM :

   [root@server SmartCard]# scp config-client-for-smart-card-auth.sh root@client.idm.example.com:/root/SmartCard/
   Password:
   config-client-for-smart-card-auth.sh        100%   2419       3.5MB/s   00:00

3. À partir du serveur IdM, copiez les fichiers de certificats d'autorité de certification au format PEM, pour plus de commodité, dans le même répertoire de la machine du client IdM que celui utilisé à l'étape précédente :

   [root@server SmartCard]# scp {rootca.pem,subca.pem,issuingca.pem} root@client.idm.example.com:/root/SmartCard/
   Password:
   rootca.pem                          100%   1237     9.6KB/s   00:00
   subca.pem                           100%   2514    19.6KB/s   00:00
   issuingca.pem                       100%   2514    19.6KB/s   00:00

4. Sur l'ordinateur client, exécutez le script en ajoutant les fichiers PEM contenant les certificats d'autorité de certification en tant qu'arguments :

   [root@client SmartCard]# kinit admin
   [root@client SmartCard]# chmod +x config-client-for-smart-card-auth.sh
   [root@client SmartCard]# ./config-client-for-smart-card-auth.sh rootca.pem subca.pem issuingca.pem
   Ticket cache:KEYRING:persistent:0:0
   Default principal: admin@IDM.EXAMPLE.COM
   [...]
   Systemwide CA database updated.
   The ipa-certupdate command was successful

   Note

   Assurez-vous que vous ajoutez le certificat de l'autorité de certification racine en tant qu'argument avant tout certificat d'autorité de certification secondaire et que les certificats de l'autorité de certification ou de l'autorité de certification secondaire n'ont pas expiré.

Procédure

1. Si vos certificats d'autorité de certification sont stockés dans des fichiers d'un format différent, tel que DER, convertissez-les au format PEM:

   # openssl x509 -in <filename>.der -inform DER -out <filename>.pem -outform PEM

   Le certificat de l'autorité de certification IdM est au format PEM et se trouve dans le fichier /etc/ipa/ca.crt.

2. En option, utilisez l'utilitaire openssl x509 pour visualiser le contenu des fichiers au format PEM et vérifier que les valeurs Issuer et Subject sont correctes :

   # openssl x509 -noout -text -in root-ca.pem | more

3. Sur votre nœud de contrôle Ansible, naviguez jusqu'à votre répertoire ~/MyPlaybooks/ répertoire :

   $ cd ~/MyPlaybooks/

4. Créez un sous-répertoire dédié aux certificats d'autorité de certification :

   $ mkdir SmartCard/

5. Pour plus de commodité, copiez tous les certificats requis dans le répertoire ~/MyPlaybooks/SmartCard/, par exemple :

   # cp /tmp/root-ca.pem ~/MyPlaybooks/SmartCard/
   # cp /tmp/intermediate-ca.pem ~/MyPlaybooks/SmartCard/
   # cp /etc/ipa/ca.crt ~/MyPlaybooks/SmartCard/ipa-ca.crt

6. Dans votre fichier d'inventaire Ansible, spécifiez ce qui suit :

   • Les clients IdM que vous souhaitez configurer pour l'authentification par carte à puce.
   • Le mot de passe de l'administrateur de l'IdM.

   • Les chemins d'accès aux certificats des autorités de certification dans l'ordre suivant :

     • Le fichier du certificat de l'autorité de certification racine
     • Les fichiers des certificats de l'autorité de certification intermédiaire
     • Le fichier du certificat de l'autorité de certification IdM

   Le fichier peut se présenter comme suit :

   [ipaclients]
   ipaclient1.example.com
   ipaclient2.example.com
   
   [ipaclients:vars]
   ipaadmin_password=SomeADMINpassword
   ipasmartcard_client_ca_certs=/home/<user_name>/MyPlaybooks/SmartCard/root-ca.pem,/home/<user_name>/MyPlaybooks/SmartCard/intermediate-ca.pem,/home/<user_name>/MyPlaybooks/SmartCard/ipa-ca.crt

7. Créez un playbook install-smartcard-clients.yml avec le contenu suivant :

   ---
   - name: Playbook to set up smart card authentication for an IdM client
     hosts: ipaclients
     become: true
   
     roles:
     - role: ipasmartcard_client
       state: present

8. Enregistrer le fichier.

9. Exécutez le playbook Ansible. Spécifiez le playbook et les fichiers d'inventaire :

   $ ansible-playbook --vault-password-file=password_file -v -i inventory install-smartcard-clients.yml

   Le rôle ipasmartcard_client Ansible effectue les actions suivantes :

   • Il configure le démon de la carte à puce.
   • Il définit la réserve de confiance du système.
   • Il configure le System Security Services Daemon (SSSD) pour permettre aux utilisateurs de s'authentifier soit avec leur nom d'utilisateur et leur mot de passe, soit avec leur carte à puce. Pour plus de détails sur les options de profil SSSD pour l'authentification par carte à puce, voir Options d'authentification par carte à puce dans RHEL.

Procédure

1. Connectez-vous à l'interface Web IdM en tant qu'administrateur si vous souhaitez ajouter un certificat à un autre utilisateur. Pour ajouter un certificat à votre propre profil, vous n'avez pas besoin des informations d'identification de l'administrateur.
2. Naviguez vers Users → Active users → sc_user.
3. Recherchez l'option Certificate et cliquez sur Add.

4. Sur le site Command-Line Interface, affichez le certificat au format PEM à l'aide de l'utilitaire cat ou d'un éditeur de texte :

   [user@client SmartCard]$ cat testuser.crt

5. Copiez et collez le certificat de l'interface de gestion dans la fenêtre qui s'est ouverte dans l'interface Web.

6. Cliquez sur Add.

   Figure 2.1. Ajout d'un nouveau certificat dans l'interface Web IdM

   

Procédure

1. Connectez-vous au CLI IdM en tant qu'administrateur si vous souhaitez ajouter un certificat à un autre utilisateur :

   [user@client SmartCard]$ kinit admin

   Pour ajouter un certificat à votre propre profil, vous n'avez pas besoin des informations d'identification de l'administrateur :

   [user@client SmartCard]$ kinit sc_user

2. Créez une variable d'environnement contenant le certificat dont l'en-tête et le pied de page ont été supprimés et concaténés en une seule ligne, ce qui correspond au format attendu par la commande ipa user-add-cert:

   [user@client SmartCard]$ export CERT=`openssl x509 -outform der -in testuser.crt | base64 -w0 -`

   Notez que le certificat dans le fichier testuser.crt doit être au format PEM.

3. Ajoutez le certificat au profil de l'utilisateur sc_user à l'aide de la commande ipa user-add-cert:

   [user@client SmartCard]$ ipa user-add-cert sc_user --certificate=$CERT

Procédure

1. Installez les paquets opensc et gnutls-utils:

   # dnf -y install opensc gnutls-utils

2. Démarrez le service pcscd.

   # systemctl start pcscd

Procédure

1. Effacez votre carte à puce et authentifiez-vous avec votre code PIN :

   $ pkcs15-init --erase-card --use-default-transport-keys
   Using reader with a card: Reader name
   PIN [Security Officer PIN] required.
   Please enter PIN [Security Officer PIN]:

   La carte a été effacée.

2. Initialisez votre carte à puce, définissez votre code PIN et PUK d'utilisateur, ainsi que le code PIN et PUK de votre responsable de la sécurité :

   $ pkcs15-init --create-pkcs15 --use-default-transport-keys \
       --pin 963214 --puk 321478 --so-pin 65498714 --so-puk 784123
   Using reader with a card: Reader name

   L'outil pcks15-init crée un nouvel emplacement sur la carte à puce.

3. Définir l'étiquette et l'ID d'authentification pour l'emplacement :

   $ pkcs15-init --store-pin --label testuser \
       --auth-id 01 --so-pin 65498714 --pin 963214 --puk 321478
   Using reader with a card: Reader name

   L'étiquette est définie sur une valeur lisible par l'homme, dans ce cas, testuser. L'adresse auth-id doit être composée de deux valeurs hexadécimales ; dans ce cas, elle est fixée à 01.

4. Stockez et étiquetez la clé privée dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-private-key testuser.key --label testuser_key \
       --auth-id 01 --id 01 --pin 963214
   Using reader with a card: Reader name

   Note

   La valeur que vous indiquez pour --id doit être la même lorsque vous stockez votre clé privée et votre certificat à l'étape suivante. Il est recommandé de spécifier votre propre valeur pour --id, sinon l'outil calculera une valeur plus complexe.

5. Stockez et étiquetez le certificat dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-certificate testuser.crt --label testuser_crt \
       --auth-id 01 --id 01 --format pem --pin 963214
   Using reader with a card: Reader name

6. (Facultatif) Stockez et étiquetez la clé publique dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-public-key testuserpublic.key
       --label testuserpublic_key --auth-id 01 --id 01 --pin 963214
   Using reader with a card: Reader name

   Note

   Si la clé publique correspond à une clé privée ou à un certificat, indiquez le même ID que celui de la clé privée ou du certificat.

7. (Facultatif) Certaines cartes à puce exigent que vous finalisiez la carte en verrouillant les paramètres :

   $ pkcs15-init -F

   À ce stade, votre carte à puce comprend le certificat, la clé privée et la clé publique dans l'emplacement nouvellement créé. Vous avez également créé votre code PIN et PUK d'utilisateur ainsi que le code PIN et PUK de l'agent de sécurité.

Procédure

1. Ouvrez l'interface Web IdM dans le navigateur.

2. Cliquez sur Log In Using Certificate.

   

3. Si la boîte de dialogue Password Required s'ouvre, ajoutez le code PIN pour déverrouiller la carte à puce et cliquez sur le bouton OK.

   La boîte de dialogue User Identification Request s'ouvre.

   Si la carte à puce contient plus d'un certificat, sélectionnez le certificat que vous souhaitez utiliser pour l'authentification dans la liste déroulante située sous Choose a certificate to present as identification.

4. Cliquez sur le bouton OK.

Procédure

1. Insérez la carte à puce dans le lecteur.
2. Saisissez le code PIN de la carte à puce.
3. Cliquez sur Sign In.

Procédure

1. Connectez-vous à partir de the IdM server et copiez le certificat racine de adcs-winserver-ca.cer sur le serveur IdM :

   root@idmserver ~]# sftp Administrator@winserver.ad.example.com
   Administrator@winserver.ad.example.com's password:
   Connected to Administrator@winserver.ad.example.com.
   sftp> cd <Path to certificates>
   sftp> ls
   adcs-winserver-ca.cer    aduser1.pfx
   sftp>
   sftp> get adcs-winserver-ca.cer
   Fetching <Path to certificates>/adcs-winserver-ca.cer to adcs-winserver-ca.cer
   <Path to certificates>/adcs-winserver-ca.cer                 100%  1254    15KB/s 00:00
   sftp quit

2. Connectez-vous à partir de the IdM client et copiez le certificat d'utilisateur de aduser1.pfx sur le client :

   [root@client1 ~]# sftp Administrator@winserver.ad.example.com
   Administrator@winserver.ad.example.com's password:
   Connected to Administrator@winserver.ad.example.com.
   sftp> cd /<Path to certificates>
   sftp> get aduser1.pfx
   Fetching <Path to certificates>/aduser1.pfx to aduser1.pfx
   <Path to certificates>/aduser1.pfx                 100%  1254    15KB/s 00:00
   sftp quit

Procédure

1. Sur le serveur IdM, utilisez le script ipa-advise pour configurer un client :

   [root@idmserver ~]# ipa-advise config-client-for-smart-card-auth > sc_client.sh

2. Sur le serveur IdM, utilisez le script ipa-advise pour configurer un serveur :

   [root@idmserver ~]# ipa-advise config-server-for-smart-card-auth > sc_server.sh

3. Sur le serveur IdM, exécuter le script :

   [root@idmserver ~]# sh -x sc_server.sh adcs-winserver-ca.cer

   • Il configure le serveur HTTP Apache de l'IdM.
   • Il active la cryptographie à clé publique pour l'authentification initiale dans Kerberos (PKINIT) sur le centre de distribution de clés (KDC).
   • Il configure l'interface Web IdM pour qu'elle accepte les demandes d'autorisation de carte à puce.

4. Copiez le script sc_client.sh sur le système client :

   [root@idmserver ~]# scp sc_client.sh root@client1.idm.example.com:/root
   Password:
   sc_client.sh                  100%  2857   1.6MB/s   00:00

5. Copiez le certificat Windows sur le système client :

   [root@idmserver ~]# scp adcs-winserver-ca.cer root@client1.idm.example.com:/root
   Password:
   adcs-winserver-ca.cer                 100%  1254   952.0KB/s   00:00

6. Sur le système client, exécutez le script client :

   [root@idmclient1 ~]# sh -x sc_client.sh adcs-winserver-ca.cer

Procédure

1. Sur le client IdM, dans le format PEM :

   [root@idmclient1 ~]# openssl pkcs12 -in aduser1.pfx -out aduser1_cert_only.pem -clcerts -nodes
   Enter Import Password:

2. Extraire la clé dans un fichier séparé :

   [root@idmclient1 ~]# openssl pkcs12 -in adduser1.pfx -nocerts -out adduser1.pem > aduser1.key

3. Extraire le certificat public dans un fichier séparé :

   [root@idmclient1 ~]# openssl pkcs12 -in adduser1.pfx -clcerts -nokeys -out aduser1_cert_only.pem > aduser1.crt

Procédure

1. Installez les paquets opensc et gnutls-utils:

   # dnf -y install opensc gnutls-utils

2. Démarrez le service pcscd.

   # systemctl start pcscd

Procédure

1. Effacez votre carte à puce et authentifiez-vous avec votre code PIN :

   $ pkcs15-init --erase-card --use-default-transport-keys
   Using reader with a card: Reader name
   PIN [Security Officer PIN] required.
   Please enter PIN [Security Officer PIN]:

   La carte a été effacée.

2. Initialisez votre carte à puce, définissez votre code PIN et PUK d'utilisateur, ainsi que le code PIN et PUK de votre responsable de la sécurité :

   $ pkcs15-init --create-pkcs15 --use-default-transport-keys \
       --pin 963214 --puk 321478 --so-pin 65498714 --so-puk 784123
   Using reader with a card: Reader name

   L'outil pcks15-init crée un nouvel emplacement sur la carte à puce.

3. Définir l'étiquette et l'ID d'authentification pour l'emplacement :

   $ pkcs15-init --store-pin --label testuser \
       --auth-id 01 --so-pin 65498714 --pin 963214 --puk 321478
   Using reader with a card: Reader name

   L'étiquette est définie sur une valeur lisible par l'homme, dans ce cas, testuser. L'adresse auth-id doit être composée de deux valeurs hexadécimales ; dans ce cas, elle est fixée à 01.

4. Stockez et étiquetez la clé privée dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-private-key testuser.key --label testuser_key \
       --auth-id 01 --id 01 --pin 963214
   Using reader with a card: Reader name

   Note

   La valeur que vous indiquez pour --id doit être la même lorsque vous stockez votre clé privée et votre certificat à l'étape suivante. Il est recommandé de spécifier votre propre valeur pour --id, sinon l'outil calculera une valeur plus complexe.

5. Stockez et étiquetez le certificat dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-certificate testuser.crt --label testuser_crt \
       --auth-id 01 --id 01 --format pem --pin 963214
   Using reader with a card: Reader name

6. (Facultatif) Stockez et étiquetez la clé publique dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-public-key testuserpublic.key
       --label testuserpublic_key --auth-id 01 --id 01 --pin 963214
   Using reader with a card: Reader name

   Note

   Si la clé publique correspond à une clé privée ou à un certificat, indiquez le même ID que celui de la clé privée ou du certificat.

7. (Facultatif) Certaines cartes à puce exigent que vous finalisiez la carte en verrouillant les paramètres :

   $ pkcs15-init -F

   À ce stade, votre carte à puce comprend le certificat, la clé privée et la clé publique dans l'emplacement nouvellement créé. Vous avez également créé votre code PIN et PUK d'utilisateur ainsi que le code PIN et PUK de l'agent de sécurité.

Procédure

1. Ouvrez le fichier sssd.conf:

   [root@idmclient1 ~]# vim /etc/sssd/sssd.conf

2. Modifier la valeur de p11_child_timeout:

   [pam]
   p11_child_timeout = 60

3. Modifier la valeur de krb5_auth_timeout:

   [domain/IDM.EXAMPLE.COM]
   krb5_auth_timeout = 60

4. Sauvegarder les paramètres.

Procédure

1. Obtenez les informations sur l'utilisateur à partir du certificat. Utilisez l'utilitaire d'affichage et de signature de certificats openssl x509 avec :

   • l'option -noout pour empêcher la sortie d'une version encodée de la requête
   • l'option -issuer pour éditer le nom de l'émetteur
   • l'option -in pour spécifier le nom du fichier d'entrée à partir duquel le certificat doit être lu

   • l'option -nameopt avec la valeur RFC2253 pour afficher la sortie avec le nom distinctif relatif (RDN) le plus spécifique en premier

     Si le fichier d'entrée contient un certificat de gestion d'identité, la sortie de la commande montre que l'émetteur est défini à l'aide des informations de Organisation:

     # openssl x509 -noout -issuer -in idm_user.crt -nameopt RFC2253
     issuer=CN=Certificate Authority,O=REALM.EXAMPLE.COM

     Si le fichier d'entrée contient un certificat Active Directory, la sortie de la commande montre que l'émetteur est défini à l'aide des informations de Domain Component:

     # openssl x509 -noout -issuer -in ad_user.crt -nameopt RFC2253
     issuer=CN=AD-WIN2012R2-CA,DC=AD,DC=EXAMPLE,DC=COM

2. Optionnellement, pour créer une nouvelle règle de mappage dans le CLI basée sur une règle de correspondance qui spécifie que l'émetteur du certificat doit être le AD-WIN2012R2-CA extrait du domaine ad.example.com et que le sujet du certificat doit correspondre à l'entrée certmapdata dans un compte d'utilisateur dans l'IdM :

   # ipa certmaprule-add simple_rule --matchrule '<ISSUER>CN=AD-WIN2012R2-CA,DC=AD,DC=EXAMPLE,DC=COM' --maprule '(ipacertmapdata=X509:<I>{issuer_dn!nss_x500}<S>{subject_dn!nss_x500})'

Procédure

1. Installez les paquets opensc et gnutls-utils:

   # dnf -y install opensc gnutls-utils

2. Démarrez le service pcscd.

   # systemctl start pcscd

Procédure

1. Effacez votre carte à puce et authentifiez-vous avec votre code PIN :

   $ pkcs15-init --erase-card --use-default-transport-keys
   Using reader with a card: Reader name
   PIN [Security Officer PIN] required.
   Please enter PIN [Security Officer PIN]:

   La carte a été effacée.

2. Initialisez votre carte à puce, définissez votre code PIN et PUK d'utilisateur, ainsi que le code PIN et PUK de votre responsable de la sécurité :

   $ pkcs15-init --create-pkcs15 --use-default-transport-keys \
       --pin 963214 --puk 321478 --so-pin 65498714 --so-puk 784123
   Using reader with a card: Reader name

   L'outil pcks15-init crée un nouvel emplacement sur la carte à puce.

3. Définir l'étiquette et l'ID d'authentification pour l'emplacement :

   $ pkcs15-init --store-pin --label testuser \
       --auth-id 01 --so-pin 65498714 --pin 963214 --puk 321478
   Using reader with a card: Reader name

   L'étiquette est définie sur une valeur lisible par l'homme, dans ce cas, testuser. L'adresse auth-id doit être composée de deux valeurs hexadécimales ; dans ce cas, elle est fixée à 01.

4. Stockez et étiquetez la clé privée dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-private-key testuser.key --label testuser_key \
       --auth-id 01 --id 01 --pin 963214
   Using reader with a card: Reader name

   Note

   La valeur que vous indiquez pour --id doit être la même lorsque vous stockez votre clé privée et votre certificat à l'étape suivante. Il est recommandé de spécifier votre propre valeur pour --id, sinon l'outil calculera une valeur plus complexe.

5. Stockez et étiquetez le certificat dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-certificate testuser.crt --label testuser_crt \
       --auth-id 01 --id 01 --format pem --pin 963214
   Using reader with a card: Reader name

6. (Facultatif) Stockez et étiquetez la clé publique dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-public-key testuserpublic.key
       --label testuserpublic_key --auth-id 01 --id 01 --pin 963214
   Using reader with a card: Reader name

   Note

   Si la clé publique correspond à une clé privée ou à un certificat, indiquez le même ID que celui de la clé privée ou du certificat.

7. (Facultatif) Certaines cartes à puce exigent que vous finalisiez la carte en verrouillant les paramètres :

   $ pkcs15-init -F

   À ce stade, votre carte à puce comprend le certificat, la clé privée et la clé publique dans l'emplacement nouvellement créé. Vous avez également créé votre code PIN et PUK d'utilisateur ainsi que le code PIN et PUK de l'agent de sécurité.

Procédure

1. Ouvrez votre navigateur web et ajoutez l'adresse de la console web dans la barre d'adresse.

   Le navigateur vous demande d'ajouter le code PIN protégeant le certificat stocké sur la carte à puce.

2. Dans la boîte de dialogue Password Required, saisissez le code PIN et cliquez sur OK.
3. Dans la boîte de dialogue User Identification Request, sélectionnez le certificat stocké dans la carte à puce.

4. Sélectionnez Remember this decision.

   Le système n'ouvre pas cette fenêtre la prochaine fois.

   Note

   Cette étape ne s'applique pas aux utilisateurs de Google Chrome.

5. Cliquez sur OK.

Procédure

1. Définir des règles de délégation des contraintes pour dresser la liste des hôtes auxquels le ticket peut accéder.

   Exemple 5.1. Mise en place de règles de délégation de contraintes

   La session de la console web s'exécute sur l'hôte host.example.com et doit être autorisée à accéder à son propre hôte avec sudo. De plus, nous ajoutons un deuxième hôte de confiance - remote.example.com.

   • Créer la délégation suivante :

     • Exécutez les commandes suivantes pour ajouter une liste de machines cibles auxquelles une règle particulière peut accéder :

       # ipa servicedelegationtarget-add cockpit-target
       # ipa servicedelegationtarget-add-member cockpit-target \
          --principals=host/host.example.com@EXAMPLE.COM \
          --principals=host/remote.example.com@EXAMPLE.COM

     • Pour autoriser les sessions de la console web (HTTP/principal) à accéder à cette liste d'hôtes, exécutez les commandes suivantes :

       # ipa servicedelegationrule-add cockpit-delegation
       # ipa servicedelegationrule-add-member cockpit-delegation \
         --principals=HTTP/host.example.com@EXAMPLE.COM
       # ipa servicedelegationrule-add-target cockpit-delegation \
         --servicedelegationtargets=cockpit-target

2. Activer l'authentification GSS dans les services correspondants :

   1. Pour sudo, activez le module pam_sss_gss dans le fichier /etc/sssd/sssd.conf:

      1. En tant que root, ajoutez une entrée pour votre domaine dans le fichier de configuration /etc/sssd/sssd.conf.

         [domain/example.com]
         pam_gssapi_services = sudo, sudo-i

      2. Activez le module dans le fichier /etc/pam.d/sudo sur la première ligne.

         auth sufficient pam_sss_gss.so

   2. Pour SSH, mettez à jour l'option GSSAPIAuthentication du fichier /etc/ssh/sshd_config en yes.

Vérification

1. Connectez-vous à la console web à l'aide d'une carte à puce.
2. Cliquez sur le bouton Limited access.
3. Authentifiez-vous à l'aide de votre carte à puce.

1. Essayez de vous connecter à un autre hôte avec SSH.

Procédure

1. Dans le terminal, ouvrez le fichier de configuration system-cockpithttps.slice:

   # systemctl edit system-cockpithttps.slice

2. Limitez les TasksMax à 100 et les CPUQuota à 30%:

   [Slice]
   # change existing value
   TasksMax=100
   # add new restriction
   CPUQuota=30%

3. Pour appliquer les modifications, redémarrez le système :

   # systemctl daemon-reload
   # systemctl stop cockpit

Procédure

1. Créez un répertoire où vous pourrez générer le certificat, par exemple :

   # mkdir /tmp/ca
   # cd /tmp/ca

2. Mettre en place le certificat (copier ce texte sur votre ligne de commande dans le répertoire ca ) :

   cat > ca.cnf <<EOF
   [ ca ]
   default_ca = CA_default
   
   [ CA_default ]
   dir              = .
   database         = \$dir/index.txt
   new_certs_dir    = \$dir/newcerts
   
   certificate      = \$dir/rootCA.crt
   serial           = \$dir/serial
   private_key      = \$dir/rootCA.key
   RANDFILE         = \$dir/rand
   
   default_days     = 365
   default_crl_days = 30
   default_md       = sha256
   
   policy           = policy_any
   email_in_dn      = no
   
   name_opt         = ca_default
   cert_opt         = ca_default
   copy_extensions  = copy
   
   [ usr_cert ]
   authorityKeyIdentifier = keyid, issuer
   
   [ v3_ca ]
   subjectKeyIdentifier   = hash
   authorityKeyIdentifier = keyid:always,issuer:always
   basicConstraints       = CA:true
   keyUsage               = critical, digitalSignature, cRLSign, keyCertSign
   
   [ policy_any ]
   organizationName       = supplied
   organizationalUnitName = supplied
   commonName             = supplied
   emailAddress           = optional
   
   [ req ]
   distinguished_name = req_distinguished_name
   prompt             = no
   
   [ req_distinguished_name ]
   O  = Example
   OU = Example Test
   CN = Example Test CA
   EOF

3. Créez les répertoires suivants :

   # mkdir certs crl newcerts

4. Créez les fichiers suivants :

   # touch index.txt crlnumber index.txt.attr

5. Inscrivez le numéro 01 dans le fichier série :

   # echo 01 > serial

   Cette commande écrit un numéro 01 dans le fichier de série. Il s'agit du numéro de série du certificat. Ce numéro augmente d'une unité à chaque nouveau certificat délivré par l'autorité de certification.

6. Créer une clé d'autorité de certification racine OpenSSL :

   # openssl genrsa -out rootCA.key 2048

7. Créer un certificat d'autorité de certification racine auto-signé :

   # openssl req -batch -config ca.cnf \
       -x509 -new -nodes -key rootCA.key -sha256 -days 10000 \
       -set_serial 0 -extensions v3_ca -out rootCA.crt

8. Créez la clé de votre nom d'utilisateur :

   # openssl genrsa -out example.user.key 2048

   Cette clé est générée dans le système local, qui n'est pas sécurisé. Il faut donc retirer la clé du système lorsqu'elle est stockée dans la carte.

   Vous pouvez également créer une clé directement dans la carte à puce. Pour ce faire, suivez les instructions du fabricant de votre carte à puce.

9. Créez le fichier de configuration de la demande de signature de certificat (copiez ce texte sur votre ligne de commande dans le répertoire ca) :

   cat > req.cnf <<EOF
   [ req ]
   distinguished_name = req_distinguished_name
   prompt = no
   
   [ req_distinguished_name ]
   O = Example
   OU = Example Test
   CN = testuser
   
   [ req_exts ]
   basicConstraints = CA:FALSE
   nsCertType = client, email
   nsComment = "testuser"
   subjectKeyIdentifier = hash
   keyUsage = critical, nonRepudiation, digitalSignature, keyEncipherment
   extendedKeyUsage = clientAuth, emailProtection, msSmartcardLogin
   subjectAltName = otherName:msUPN;UTF8:testuser@EXAMPLE.COM, email:testuser@example.com
   EOF

10. Créez une demande de signature de certificat pour votre certificat example.user :

    # openssl req -new -nodes -key example.user.key \
        -reqexts req_exts -config req.cnf -out example.user.csr

11. Configurez le nouveau certificat. La période d'expiration est fixée à 1 an :

    # openssl ca -config ca.cnf -batch -notext \
        -keyfile rootCA.key -in example.user.csr -days 365 \
        -extensions usr_cert -out example.user.crt

Procédure

1. Assurez-vous que SSSD est installé sur le système.

   # rpm -q sssd
   sssd-2.0.0.43.el8_0.3.x86_64

2. Créez un répertoire /etc/sssd/pki:

   # file /etc/sssd/pki
   /etc/sssd/pki/: directory

3. Copiez le fichier rootCA.crt en tant que fichier PEM dans le répertoire /etc/sssd/pki/:

   # cp /tmp/ca/rootCA.crt /etc/sssd/pki/sssd_auth_ca_db.pem

Procédure

1. Installez les paquets opensc et gnutls-utils:

   # dnf -y install opensc gnutls-utils

2. Démarrez le service pcscd.

   # systemctl start pcscd

Procédure

1. Effacez votre carte à puce et authentifiez-vous avec votre code PIN :

   $ pkcs15-init --erase-card --use-default-transport-keys
   Using reader with a card: Reader name
   PIN [Security Officer PIN] required.
   Please enter PIN [Security Officer PIN]:

   La carte a été effacée.

2. Initialisez votre carte à puce, définissez votre code PIN et PUK d'utilisateur, ainsi que le code PIN et PUK de votre responsable de la sécurité :

   $ pkcs15-init --create-pkcs15 --use-default-transport-keys \
       --pin 963214 --puk 321478 --so-pin 65498714 --so-puk 784123
   Using reader with a card: Reader name

   L'outil pcks15-init crée un nouvel emplacement sur la carte à puce.

3. Définir l'étiquette et l'ID d'authentification pour l'emplacement :

   $ pkcs15-init --store-pin --label testuser \
       --auth-id 01 --so-pin 65498714 --pin 963214 --puk 321478
   Using reader with a card: Reader name

   L'étiquette est définie sur une valeur lisible par l'homme, dans ce cas, testuser. L'adresse auth-id doit être composée de deux valeurs hexadécimales ; dans ce cas, elle est fixée à 01.

4. Stockez et étiquetez la clé privée dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-private-key testuser.key --label testuser_key \
       --auth-id 01 --id 01 --pin 963214
   Using reader with a card: Reader name

   Note

   La valeur que vous indiquez pour --id doit être la même lorsque vous stockez votre clé privée et votre certificat à l'étape suivante. Il est recommandé de spécifier votre propre valeur pour --id, sinon l'outil calculera une valeur plus complexe.

5. Stockez et étiquetez le certificat dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-certificate testuser.crt --label testuser_crt \
       --auth-id 01 --id 01 --format pem --pin 963214
   Using reader with a card: Reader name

6. (Facultatif) Stockez et étiquetez la clé publique dans le nouvel emplacement de la carte à puce :

   $ pkcs15-init --store-public-key testuserpublic.key
       --label testuserpublic_key --auth-id 01 --id 01 --pin 963214
   Using reader with a card: Reader name

   Note

   Si la clé publique correspond à une clé privée ou à un certificat, indiquez le même ID que celui de la clé privée ou du certificat.

7. (Facultatif) Certaines cartes à puce exigent que vous finalisiez la carte en verrouillant les paramètres :

   $ pkcs15-init -F

   À ce stade, votre carte à puce comprend le certificat, la clé privée et la clé publique dans l'emplacement nouvellement créé. Vous avez également créé votre code PIN et PUK d'utilisateur ainsi que le code PIN et PUK de l'agent de sécurité.

Procédure

1. Créez un nouveau répertoire pour les clés SSH dans le répertoire personnel de l'utilisateur qui utilise l'authentification par carte à puce :

   # mkdir /home/example.user/.ssh

2. Exécutez la commande ssh-keygen -D avec la bibliothèque opensc pour récupérer la clé publique existante associée à la clé privée de la carte à puce, et ajoutez-la à la liste authorized_keys du répertoire des clés SSH de l'utilisateur pour activer l'accès SSH avec l'authentification par carte à puce.

   # ssh-keygen -D /usr/lib64/pkcs11/opensc-pkcs11.so >> ~exemple.user/.ssh/authorized_keys

3. SSH nécessite la configuration des droits d'accès au répertoire /.ssh et au fichier authorized_keys. Pour définir ou modifier les droits d'accès, entrez :

   # chown -R example.user:example.user ~example.user/.ssh/
   # chmod 700 ~example.user/.ssh/
   # chmod 600 ~example.user/.ssh/authorized_keys

4. En option, afficher les touches :

   # cat ~example.user/.ssh/authorized_keys

   Le terminal affiche les touches.

5. Vérifiez que l'authentification par carte à puce est activée dans le fichier /etc/sssd/sssd.conf:

   Dans la section [pam], activez le module d'authentification par certificat pam : pam_cert_auth = True

   Si le fichier sssd.conf n'a pas encore été créé, vous pouvez créer la configuration fonctionnelle minimale en copiant le script suivant sur la ligne de commande :

   # cat > /etc/sssd/sssd.conf <<EOF
   [sssd]
   services = nss, pam
   domains = shadowutils
   
   [nss]
   
   [pam]
   pam_cert_auth = True
   
   [domain/shadowutils]
   id_provider = files
   EOF

6. Pour utiliser les clés SSH, configurez l'authentification avec la commande authselect:

   # authselect select sssd with-smartcard --force

Procédure

1. Créez une règle sudo nommée adminrule pour permettre à un utilisateur d'exécuter des commandes.

   ipa sudorule-add adminrule

2. Ajouter less et whoami en tant que commandes sudo:

   ipa sudocmd-add /usr/bin/less
   ipa sudocmd-add /usr/bin/whoami

3. Ajoutez les commandes less et whoami à la commande adminrule:

   ipa sudorule-add-allow-command adminrule --sudocmds /usr/bin/less
   ipa sudorule-add-allow-command adminrule --sudocmds /usr/bin/whoami

4. Ajouter l'utilisateur ipauser1 à l'utilisateur adminrule:

   ipa sudorule-add-user adminrule --users ipauser1

5. Ajoutez l'hôte sur lequel vous exécutez sudo à la liste adminrule:

   ipa sudorule-add-host adminrule --hosts server.ipa.test

Procédure

1. Installer l'agent PAM SSH :

   dnf -y install pam_ssh_agent_auth

2. Ajoutez l'adresse authorized_keys_command pour pam_ssh_agent_auth.so au fichier /etc/pam.d/sudo avant toute autre entrée auth:

   #%PAM-1.0
   auth sufficient pam_ssh_agent_auth.so authorized_keys_command=/usr/bin/sss_ssh_authorizedkeys
   auth       include      system-auth
   account    include      system-auth
   password   include      system-auth
   session    include      system-auth

3. Pour permettre à la redirection de l'agent SSH de fonctionner lorsque vous exécutez des commandes sudo, ajoutez ce qui suit au fichier /etc/sudoers:

   Valeurs par défaut env_keep = "SSH_AUTH_SOCK"

   Cela permet aux utilisateurs dont les clés publiques des cartes à puce sont stockées dans IPA/SSSD de s'authentifier auprès de sudo sans saisir de mot de passe.

4. Redémarrez le service sssd:

   systemctl restart sssd

Procédure

1. Démarrez l'agent SSH (s'il n'est pas déjà en cours d'exécution).

   eval `ssh-agent`

2. Ajoutez votre carte à puce à l'agent SSH. Saisissez votre code PIN lorsque vous y êtes invité :

   ssh-add -s /usr/lib64/opensc-pkcs11.so

3. Connectez-vous au système sur lequel vous devez exécuter sudo à distance en utilisant SSH avec la fonction ssh-agent forwarding activée. Utilisez l'option -A:

   ssh -A ipauser1@server.ipa.test

Procédure

1. À l'aide de la commande lsusb, vérifiez que le lecteur de cartes à puce est visible par le système d'exploitation :

   $ lsusb
   Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
   Bus 001 Device 003: ID 072f:b100 Advanced Card Systems, Ltd ACR39U
   Bus 001 Device 002: ID 0627:0001 Adomax Technology Co., Ltd
   Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

   Pour plus d'informations sur les cartes à puce et les lecteurs testés et pris en charge par RHEL, voir Prise en charge des cartes à puce dans RHEL 9.

2. Assurez-vous que le service et le socket pcscd sont activés et en cours d'exécution :

   $ systemctl status pcscd.service pcscd.socket
   
   ● pcscd.service - PC/SC Smart Card Daemon
         Loaded: loaded (/usr/lib/systemd/system/pcscd.service; indirect;
   vendor preset: disabled)
         Active: active (running) since Fri 2021-09-24 11:05:04 CEST; 2
   weeks 6 days ago
   TriggeredBy: ● pcscd.socket
           Docs: man:pcscd(8)
       Main PID: 3772184 (pcscd)
          Tasks: 12 (limit: 38201)
         Memory: 8.2M
            CPU: 1min 8.067s
         CGroup: /system.slice/pcscd.service
                 └─3772184 /usr/sbin/pcscd --foreground --auto-exit
   
   ● pcscd.socket - PC/SC Smart Card Daemon Activation Socket
         Loaded: loaded (/usr/lib/systemd/system/pcscd.socket; enabled;
   vendor preset: enabled)
         Active: active (running) since Fri 2021-09-24 11:05:04 CEST; 2
   weeks 6 days ago
       Triggers: ● pcscd.service
         Listen: /run/pcscd/pcscd.comm (Stream)
         CGroup: /system.slice/pcscd.socket

3. À l'aide de la commande p11-kit list-modules, affichez des informations sur la carte à puce configurée et les jetons présents sur la carte à puce :

   $ p11-kit list-modules
   p11-kit-trust: p11-kit-trust.so
   [...]
   opensc: opensc-pkcs11.so
       library-description: OpenSC smartcard framework
       library-manufacturer: OpenSC Project
       library-version: 0.20
       token: MyEID (sctest)
           manufacturer: Aventra Ltd.
           model: PKCS#15
           serial-number: 8185043840990797
           firmware-version: 40.1
           flags:
                  rng
                  login-required
                  user-pin-initialized
                  token-initialized

4. Vérifiez que vous pouvez accéder au contenu de votre carte à puce :

   $ pkcs11-tool --list-objects --login
   Using slot 0 with a present token (0x0)
   Logging in to "MyEID (sctest)".
   Please enter User PIN:
   Private Key Object; RSA
     label:      Certificate
     ID:         01
     Usage:      sign
     Access:     sensitive
   Public Key Object; RSA 2048 bits
     label:      Public Key
     ID:         01
     Usage:      verify
     Access:     none
   Certificate Object; type = X.509 cert
     label:      Certificate
     subject:    DN: O=IDM.EXAMPLE.COM, CN=idmuser1
     ID:         01

5. Affichez le contenu du certificat de votre carte à puce à l'aide de la commande certutil:

   1. Exécutez la commande suivante pour déterminer le nom correct de votre certificat :

      $ certutil -d /etc/pki/nssdb -L -h all
      
      Certificate Nickname                                         Trust Attributes
                                                                   SSL,S/MIME,JAR/XPI
      
      Enter Password or Pin for "MyEID (sctest)":
      Smart Card CA 0f5019a8-7e65-46a1-afe5-8e17c256ae00           CT,C,C
      MyEID (sctest):Certificate                                   u,u,u

   2. Affichez le contenu du certificat sur votre carte à puce :

      Note

      Veillez à ce que le nom du certificat corresponde exactement à la sortie affichée à l'étape précédente, dans cet exemple MyEID (sctest):Certificate.

      $ certutil -d /etc/pki/nssdb -L -n "MyEID (sctest):Certificate"
      
      Enter Password or Pin for "MyEID (sctest)":
      Certificate:
          Data:
              Version: 3 (0x2)
              Serial Number: 15 (0xf)
              Signature Algorithm: PKCS #1 SHA-256 With RSA Encryption
              Issuer: "CN=Certificate Authority,O=IDM.EXAMPLE.COM"
              Validity:
                  Not Before: Thu Sep 30 14:01:41 2021
                  Not After : Sun Oct 01 14:01:41 2023
              Subject: "CN=idmuser1,O=IDM.EXAMPLE.COM"
              Subject Public Key Info:
                  Public Key Algorithm: PKCS #1 RSA Encryption
                  RSA Public Key:
                      Modulus:
                          [...]
                      Exponent: 65537 (0x10001)
              Signed Extensions:
                  Name: Certificate Authority Key Identifier
                  Key ID:
                      e2:27:56:0d:2f:f5:f2:72:ce:de:37:20:44:8f:18:7f:
                      2f:56:f9:1a
      
                  Name: Authority Information Access
                  Method: PKIX Online Certificate Status Protocol
                  Location:
                      URI: "http://ipa-ca.idm.example.com/ca/ocsp"
      
                  Name: Certificate Key Usage
                  Critical: True
                  Usages: Digital Signature
                          Non-Repudiation
                          Key Encipherment
                          Data Encipherment
      
                  Name: Extended Key Usage
                      TLS Web Server Authentication Certificate
                      TLS Web Client Authentication Certificate
      
                  Name: CRL Distribution Points
                  Distribution point:
                      URI: "http://ipa-ca.idm.example.com/ipa/crl/MasterCRL.bin"
                      CRL issuer:
                          Directory Name: "CN=Certificate Authority,O=ipaca"
      
                  Name: Certificate Subject Key ID
                  Data:
                      43:23:9f:c1:cf:b1:9f:51:18:be:05:b5:44:dc:e6:ab:
                      be:07:1f:36
      
          Signature Algorithm: PKCS #1 SHA-256 With RSA Encryption
          Signature:
              [...]
          Fingerprint (SHA-256):
              6A:F9:64:F7:F2:A2:B5:04:88:27:6E:B8:53:3E:44:3E:F5:75:85:91:34:ED:48:A8:0D:F0:31:5D:7B:C9:E0:EC
          Fingerprint (SHA1):
              B4:9A:59:9F:1C:A8:5D:0E:C1:A2:41:EC:FD:43:E0:80:5F:63:DF:29
      
          Mozilla-CA-Policy: false (attribute missing)
          Certificate Trust Flags:
              SSL Flags:
                  User
              Email Flags:
                  User
              Object Signing Flags:
                  User

Procédure

1. Vérifiez que vous pouvez vous authentifier avec votre carte à puce en utilisant su:

   $ su - idmuser1 -c ‘su - idmuser1 -c whoami’
   PIN for MyEID (sctest):
   idmuser1

   Si le code PIN de la carte à puce ne vous est pas demandé et qu'une invite de mot de passe ou une erreur d'autorisation est renvoyée, vérifiez les journaux SSSD. Reportez-vous à la section Dépannage de l'authentification avec SSSD dans IdM pour obtenir des informations sur la journalisation dans SSSD. Voici un exemple d'échec d'authentification :

   $ su - idmuser1 -c ‘su - idmuser1 -c whoami’
   PIN for MyEID (sctest):
   su: Authentication failure

   Si les journaux SSSD indiquent un problème à l'adresse krb5_child, similaire à ce qui suit, il se peut que vous ayez un problème avec vos certificats d'autorité de certification. Pour résoudre les problèmes liés aux certificats, voir Vérifier que le KDC Kerberos IdM peut utiliser Pkinit et que les certificats d'autorité de certification sont correctement localisés.

   [Pre-authentication failed: Failed to verify own certificate (depth 0): unable to get local issuer certificate: could not load the shared library]

   Si les journaux SSSD indiquent un dépassement de délai à partir de p11_child ou krb5_child, vous devrez peut-être augmenter les délais d'attente SSSD et réessayer de vous authentifier à l'aide de votre carte à puce. Voir Augmentation des délais d'attente SSSD pour plus de détails sur la manière d'augmenter les délais d'attente.

2. Vérifiez que la configuration de l'authentification par carte à puce GDM est correcte. Un message de succès pour l'authentification PAM devrait être renvoyé comme indiqué ci-dessous :

   # sssctl user-checks -s gdm-smartcard "idmuser1" -a auth
   user: idmuser1
   action: auth
   service: gdm-smartcard
   
   SSSD nss user lookup result:
    - user name: idmuser1
    - user id: 603200210
    - group id: 603200210
    - gecos: idm user1
    - home directory: /home/idmuser1
    - shell: /bin/sh
   
   SSSD InfoPipe user lookup result:
    - name: idmuser1
    - uidNumber: 603200210
    - gidNumber: 603200210
    - gecos: idm user1
    - homeDirectory: /home/idmuser1
    - loginShell: /bin/sh
   
   testing pam_authenticate
   
   PIN for MyEID (sctest)
   pam_authenticate for user [idmuser1]: Success
   
   PAM Environment:
    - PKCS11_LOGIN_TOKEN_NAME=MyEID (sctest)
    - KRB5CCNAME=KCM:

   Si une erreur d'authentification, semblable à la suivante, est renvoyée, vérifiez les journaux SSSD pour essayer de déterminer la cause du problème. Voir Dépannage de l'authentification avec SSSD dans IdM pour plus d'informations sur la journalisation dans SSSD.

   pam_authenticate for user [idmuser1]: Authentication failure
   
   PAM Environment:
    - no env -

   Si l'authentification PAM continue d'échouer, videz votre cache et exécutez à nouveau la commande.

   # sssctl cache-remove
   SSSD must not be running. Stop SSSD now? (yes/no) [yes] yes
   Creating backup of local data…
   Removing cache files…
   SSSD needs to be running. Start SSSD now? (yes/no) [yes] yes

Procédure

1. Exécutez l'utilitaire kinit pour vous authentifier en tant que idmuser1 avec le certificat stocké sur votre carte à puce :

   $ kinit -X X509_user_identity=PKCS11: idmuser1
   MyEID (sctest)                   PIN:

2. Saisissez le code PIN de votre carte à puce. Si vous n'êtes pas invité à saisir votre code PIN, vérifiez que vous pouvez détecter votre lecteur de carte à puce et afficher le contenu de votre carte à puce. Voir Test de l'authentification de la carte à puce.

3. Si votre code PIN est accepté et que vous êtes invité à saisir votre mot de passe, il se peut que le certificat de signature de l'autorité de certification soit manquant.

   1. Vérifiez que la chaîne de l'autorité de certification est répertoriée dans le fichier du paquet de certificats par défaut à l'aide des commandes openssl:

      $ openssl crl2pkcs7 -nocrl -certfile /var/lib/ipa-client/pki/ca-bundle.pem | openssl pkcs7 -print_certs -noout
      subject=O = IDM.EXAMPLE.COM, CN = Certificate Authority
      
      issuer=O = IDM.EXAMPLE.COM, CN = Certificate Authority

   2. Vérifiez la validité de vos certificats :

      1. Recherchez l'ID du certificat d'authentification de l'utilisateur pour idmuser1:

         $ pkcs11-tool --list-objects --login
         [...]
         Certificate Object; type = X.509 cert
           label:      Certificate
           subject:    DN: O=IDM.EXAMPLE.COM, CN=idmuser1
          ID: 01

      2. Lire les informations relatives au certificat de l'utilisateur sur la carte à puce au format DER :

         $ pkcs11-tool --read-object --id 01 --type cert --output-file cert.der
         Using slot 0 with a present token (0x0)

      3. Convertir le certificat DER au format PEM :

         $ openssl x509 -in cert.der -inform DER -out cert.pem -outform PEM

      4. Vérifiez que le certificat comporte des signatures d'émetteur valides jusqu'à l'autorité de certification :

         $ openssl verify -CAfile /var/lib/ipa-client/pki/ca-bundle.pem <path>/cert.pem
         cert.pem: OK

4. Si votre carte à puce contient plusieurs certificats, il se peut que kinit ne parvienne pas à choisir le bon certificat pour l'authentification. Dans ce cas, vous devez spécifier l'ID du certificat comme argument de la commande kinit en utilisant l'option certid=<ID>.

   1. Vérifiez combien de certificats sont stockés sur la carte à puce et obtenez l'identifiant du certificat que vous utilisez :

      $ pkcs11-tool --list-objects --type cert --login
      Using slot 0 with a present token (0x0)
      Logging in to "MyEID (sctest)".
      Please enter User PIN:
      Certificate Object; type = X.509 cert
        label:      Certificate
        subject:    DN: O=IDM.EXAMPLE.COM, CN=idmuser1
        ID:         01
      Certificate Object; type = X.509 cert
        label:      Second certificate
        subject:    DN: O=IDM.EXAMPLE.COM, CN=ipauser1
        ID:         02

   2. Exécutez kinit avec le certificat ID 01 :

      $ kinit -X kinit -X X509_user_identity=PKCS11:certid=01 idmuser1
      MyEID (sctest)                   PIN:

5. Exécutez klist pour afficher le contenu du cache des informations d'identification Kerberos :

   $ klist
   Ticket cache: KCM:0:11485
   Default principal: idmuser1@EXAMPLE.COM
   
   Valid starting       Expires              Service principal
   10/04/2021 10:50:04  10/05/2021 10:49:55  krbtgt/EXAMPLE.COM@EXAMPLE.COM

6. Détruisez vos tickets Kerberos actifs une fois que vous avez terminé :

   $ kdestroy -A

Procédure

1. Ouvrez le fichier sssd.conf sur le client IdM :

   # vim /etc/sssd/sssd.conf

2. Dans la section de votre domaine, par exemple [domain/idm.example.com], ajoutez l'option suivante :

   krb5_auth_timeout = 60

3. Dans la section [pam], ajouter ce qui suit :

   p11_child_timeout = 60

4. Effacer le cache SSSD :

   # sssctl cache-remove
   SSSD must not be running. Stop SSSD now? (yes/no) [yes] yes
   Creating backup of local data…
   Removing cache files…
   SSSD needs to be running. Start SSSD now? (yes/no) [yes] yes