Procédure

1. Ouvrez un terminal et connectez-vous au serveur IdM.

2. Saisissez ipa help topics pour afficher une liste des sujets couverts par l'aide.

   $ ipa help topics

3. Sélectionnez l'un des sujets et créez une commande selon le modèle suivant : ipa help [topic_name]. À la place de la chaîne topic_name, ajoutez l'un des thèmes énumérés à l'étape précédente.

   Dans l'exemple, nous utilisons le sujet suivant : user

   $ ipa help user

4. Si l'aide IPA est trop longue et que vous ne pouvez pas voir l'intégralité du texte, utilisez la syntaxe suivante :

   $ ipa help user | less

   Vous pouvez ensuite faire défiler la page et lire l'intégralité de l'aide.

Procédure

1. Ouvrez un terminal et connectez-vous au serveur IdM.

2. Saisissez ipa help commands pour afficher la liste des commandes couvertes par l'aide.

   $ ipa help commands

3. Sélectionnez l'une des commandes et créez une commande d'aide selon le modèle suivant : ipa help <COMMAND>. À la place de la chaîne <COMMAND>, ajoutez l'une des commandes énumérées à l'étape précédente.

   $ ipa help user-add

Procédure

1. Ouvrez un terminal et connectez-vous au serveur IdM.

2. Entrez la commande pour ajouter un nouvel utilisateur :

   $ ipa user-add

   La commande exécute un script qui vous invite à fournir les données de base nécessaires à la création d'un compte utilisateur.

3. Dans le champ First name:, entrez le prénom du nouvel utilisateur et appuyez sur la touche Enter.
4. Dans le champ Last name:, entrez le nom de famille du nouvel utilisateur et appuyez sur la touche Enter.

5. Dans le champ User login [suggested user name]:, entrez le nom d'utilisateur ou appuyez simplement sur la touche Enter pour accepter le nom d'utilisateur proposé.

   Le nom d'utilisateur doit être unique pour toute la base de données IdM. Si une erreur survient parce que ce nom d'utilisateur existe déjà, répétez le processus avec la commande ipa user-add et utilisez un nom d'utilisateur différent et unique.

Procédure

1. Ouvrez un terminal et connectez-vous au serveur IdM.

2. Entrez la commande ipa user-mod, indiquez l'utilisateur à modifier et les options éventuelles, telles que --password pour l'ajout d'un mot de passe :

   $ ipa user-mod euser --password

   La commande lance un script dans lequel vous pouvez ajouter le nouveau mot de passe.

3. Saisissez le nouveau mot de passe et appuyez sur la touche Enter.

Procédure

1. Ouvrez un terminal et connectez-vous au serveur IdM.

2. Ajoutez le login de l'utilisateur, son prénom, son nom et, éventuellement, son adresse électronique.

   $ ipa user-add user_login --first=first_name --last=last_name --email=email_address

   IdM prend en charge les noms d'utilisateurs qui peuvent être décrits par l'expression régulière suivante :

   [a-zA-Z0-9_.][a-zA-Z0-9_.-]{0,252}[a-zA-Z0-9_.$-]?

   Note

   Les noms d'utilisateur se terminant par le signe du dollar ($) sont pris en charge pour permettre la prise en charge des machines Samba 3.x.

   Si vous ajoutez un nom d'utilisateur contenant des caractères majuscules, l'IdM convertit automatiquement le nom en minuscules lorsqu'il est enregistré. Par conséquent, l'IdM exige toujours que les noms d'utilisateurs soient saisis en minuscules lors de l'ouverture d'une session. En outre, il n'est pas possible d'ajouter des noms d'utilisateurs qui ne diffèrent que par la casse des lettres, comme user et User.

   La longueur maximale par défaut des noms d'utilisateur est de 32 caractères. Pour la modifier, utilisez la commande ipa config-mod --maxusername. Par exemple, pour augmenter la longueur maximale des noms d'utilisateur à 64 caractères :

   $ ipa config-mod --maxusername=64
    Maximum username length: 64
    ...

   La commande ipa user-add comprend de nombreux paramètres. Pour les énumérer tous, utilisez la commande ipa help :

   ipa help user-add

   Pour plus d'informations sur la commande ipa help, voir Qu'est-ce que l'aide IPA?

Procédure

1. Ouvrez un terminal et connectez-vous au serveur IdM.

2. Activez le compte d'utilisateur à l'aide de la commande suivante :

   $ ipa stageuser-activate user_login
   -------------------------
   Stage user user_login activated
   -------------------------
   ...

Procédure

1. Ouvrez un terminal et connectez-vous au serveur IdM.

2. Préservez le compte d'utilisateur à l'aide de la commande suivante :

   $ ipa user-del --preserve user_login
   --------------------
   Deleted user "user_login"
   --------------------

   Note

   Bien que le résultat indique que le compte d'utilisateur a été supprimé, il a été préservé.

Procédure

1. Ouvrez un terminal et connectez-vous au serveur IdM.

2. Supprimez le compte d'utilisateur à l'aide de la commande suivante :

   $ ipa user-del user_login
   --------------------
   Deleted user "user_login"
   --------------------

Procédure

1. Ouvrez un terminal et connectez-vous au serveur IdM.

2. Activez le compte d'utilisateur à l'aide de la commande suivante :

   $ ipa user-undel user_login
   ------------------------------
   Undeleted user account "user_login"
   ------------------------------

   Vous pouvez également restaurer les comptes d'utilisateurs en tant que stades :

   $ ipa user-stage user_login
   ------------------------------
   Staged user account "user_login"
   ------------------------------

Procédure

1. Connectez-vous à l'interface Web IdM.

2. Allez sur l'onglet Users → Stage Users.

   Vous pouvez également ajouter le compte d'utilisateur sur le site Users → Active users, mais vous ne pouvez pas ajouter de groupes d'utilisateurs à ce compte.

3. Cliquez sur l'icône Add.
4. Dans la boîte de dialogue Add stage user, entrez First name et Last name du nouvel utilisateur.

5. [Facultatif] Dans le champ User login, ajoutez un nom de connexion.

   Si vous laissez ce champ vide, le serveur IdM crée le nom de connexion selon le modèle suivant : La première lettre du prénom et le nom de famille. Le nom de connexion complet peut comporter jusqu'à 32 caractères.

6. [Dans le menu déroulant GID, sélectionnez les groupes dans lesquels l'utilisateur doit être inclus.
7. [Facultatif] Dans les champs Password et Verify password, saisissez votre mot de passe et confirmez-le, en veillant à ce qu'il corresponde à votre mot de passe.

8. Cliquez sur le bouton Add.

   

Procédure

1. Connectez-vous à l'interface Web IdM.
2. Allez sur l'onglet Users → Stage users.
3. Cliquez sur la case à cocher du compte utilisateur que vous souhaitez activer.

4. Cliquez sur le bouton Activate.

   

5. Dans la boîte de dialogue Confirmation, cliquez sur le bouton OK.

Procédure

1. Connectez-vous à l'interface Web IdM.
2. Allez sur l'onglet Users → Active users.
3. Cliquez sur la case à cocher des comptes d'utilisateurs que vous souhaitez désactiver.

4. Cliquez sur le bouton Disable.

   

5. Dans la boîte de dialogue Confirmation, cliquez sur le bouton OK.

Procédure

1. Connectez-vous à l'interface Web IdM.
2. Allez sur l'onglet Users → Active users.
3. Cliquez sur la case à cocher des comptes d'utilisateurs que vous souhaitez activer.

4. Cliquez sur le bouton Enable.

   

5. Dans la boîte de dialogue Confirmation, cliquez sur le bouton OK.

Procédure

1. Connectez-vous à l'interface Web IdM.
2. Allez sur l'onglet Users → Active users.
3. Cliquez sur la case à cocher des comptes d'utilisateurs que vous souhaitez conserver.

4. Cliquez sur le bouton Delete.

   

5. Dans la boîte de dialogue Remove users, remplacez le bouton radio Delete mode par preserve.

6. Cliquez sur le bouton Delete.

   

Procédure

1. Connectez-vous à l'interface Web IdM.
2. Allez sur l'onglet Users → Preserved users.
3. Cliquez sur la case à cocher des comptes d'utilisateurs que vous souhaitez restaurer.

4. Cliquez sur le bouton Restore.

   

5. Dans la boîte de dialogue Confirmation, cliquez sur le bouton OK.

Procédure

1. Connectez-vous à l'interface Web IdM.

2. Allez sur l'onglet Users → Active users.

   Vous pouvez également supprimer le compte d'utilisateur sur le site Users → Stage users ou Users → Preserved users.

3. Cliquez sur l'icône Delete.
4. Dans la boîte de dialogue Remove users, remplacez le bouton radio Delete mode par delete.
5. Cliquez sur le bouton Delete.

Procédure

1. Créez un fichier d'inventaire, par exemple inventory.file, et définissez-y ipaserver:

   [ipaserver]
   server.idm.example.com

2. Créez un fichier Ansible playbook avec les données de l'utilisateur dont vous voulez assurer la présence dans IdM. Pour simplifier cette étape, vous pouvez copier et modifier l'exemple dans le fichier /usr/share/doc/ansible-freeipa/playbooks/user/add-user.yml. Par exemple, pour créer un utilisateur nommé idm_user et ajouter Password123 comme mot de passe :

   ---
   - name: Playbook to handle users
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Create user idm_user
       ipauser:
         ipaadmin_password: "{{ ipaadmin_password }}"
         name: idm_user
         first: Alice
         last: Acme
         uid: 1000111
         gid: 10011
         phone: "+555123457"
         email: idm_user@acme.com
         passwordexpiration: "2023-01-19 23:59:59"
         password: "Password123"
         update_password: on_create

   Vous devez utiliser les options suivantes pour ajouter un utilisateur :

   • namele nom d'utilisateur
   • first: la chaîne de caractères du prénom
   • last: la chaîne du nom de famille

   Pour la liste complète des options disponibles pour l'utilisateur, voir le fichier Markdown de /usr/share/doc/ansible-freeipa/README-user.md.

   Note

   Si vous utilisez l'option update_password: on_create, Ansible ne crée le mot de passe de l'utilisateur que lorsqu'il crée l'utilisateur. Si l'utilisateur est déjà créé avec un mot de passe, Ansible ne génère pas de nouveau mot de passe.

3. Exécutez le manuel de jeu :

   $ ansible-playbook --vault-password-file=password_file -v -i path_to_inventory_directory/inventory.file path_to_playbooks_directory/add-IdM-user.yml

Procédure

1. Créez un fichier d'inventaire, par exemple inventory.file, et définissez-y ipaserver:

   [ipaserver]
   server.idm.example.com

2. Créez un fichier Ansible playbook avec les données des utilisateurs dont vous voulez assurer la présence dans IdM. Pour simplifier cette étape, vous pouvez copier et modifier l'exemple dans le fichier /usr/share/doc/ansible-freeipa/playbooks/user/ensure-users-present.yml. Par exemple, pour créer les utilisateurs idm_user_1, idm_user_2, et idm_user_3, et ajouter Password123 comme mot de passe de idm_user_1:

   ---
   - name: Playbook to handle users
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Create user idm_users
       ipauser:
         ipaadmin_password: "{{ ipaadmin_password }}"
         users:
         - name: idm_user_1
           first: Alice
           last: Acme
           uid: 10001
           gid: 10011
           phone: "+555123457"
           email: idm_user@acme.com
           passwordexpiration: "2023-01-19 23:59:59"
           password: "Password123"
         - name: idm_user_2
           first: Bob
           last: Acme
           uid: 100011
           gid: 10011
         - name: idm_user_3
           first: Eve
           last: Acme
           uid: 1000111
           gid: 10011

   Note

   Si vous ne spécifiez pas l'option update_password: on_create, Ansible réinitialise le mot de passe de l'utilisateur à chaque fois que le livre de jeu est exécuté : si l'utilisateur a modifié le mot de passe depuis la dernière fois que le livre de jeu a été exécuté, Ansible réinitialise le mot de passe.

3. Exécutez le manuel de jeu :

   $ ansible-playbook --vault-password-file=password_file -v -i path_to_inventory_directory/inventory.file path_to_playbooks_directory/add-users.yml

Procédure

1. Créez un fichier d'inventaire, par exemple inventory.file, et définissez-y ipaserver:

   [ipaserver]
   server.idm.example.com

2. Créez un fichier playbook Ansible avec les tâches nécessaires. Référencez le fichier JSON avec les données des utilisateurs dont vous voulez assurer la présence. Pour simplifier cette étape, vous pouvez copier et modifier l'exemple dans le fichier /usr/share/doc/ansible-freeipa/ensure-users-present-ymlfile.yml:

   ---
   - name: Ensure users' presence
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Include users.json
       include_vars:
         file: users.json
   
     - name: Users present
       ipauser:
         ipaadmin_password: "{{ ipaadmin_password }}"
         users: "{{ users }}"

3. Créez le fichier users.json et ajoutez-y les utilisateurs IdM. Pour simplifier cette étape, vous pouvez copier et modifier l'exemple du fichier /usr/share/doc/ansible-freeipa/playbooks/user/users.json. Par exemple, pour créer les utilisateurs idm_user_1, idm_user_2, et idm_user_3, et ajouter Password123 comme mot de passe de idm_user_1:

   {
     "users": [
      {
       "name": "idm_user_1",
       "first": "Alice",
       "last": "Acme",
       "password": "Password123"
      },
      {
       "name": "idm_user_2",
       "first": "Bob",
       "last": "Acme"
      },
      {
       "name": "idm_user_3",
       "first": "Eve",
       "last": "Acme"
      }
     ]
   }

4. 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 path_to_inventory_directory/inventory.file path_to_playbooks_directory/ensure-users-present-jsonfile.yml

Procédure

1. Créez un fichier d'inventaire, par exemple inventory.file, et définissez-y ipaserver:

   [ipaserver]
   server.idm.example.com

2. Créez un fichier playbook Ansible avec les utilisateurs dont vous voulez garantir l'absence d'IdM. Pour simplifier cette étape, vous pouvez copier et modifier l'exemple dans le fichier /usr/share/doc/ansible-freeipa/playbooks/user/ensure-users-present.yml. Par exemple, pour supprimer les utilisateurs idm_user_1, idm_user_2, et idm_user_3:

   ---
   - name: Playbook to handle users
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Delete users idm_user_1, idm_user_2, idm_user_3
       ipauser:
         ipaadmin_password: "{{ ipaadmin_password }}"
         users:
         - name: idm_user_1
         - name: idm_user_2
         - name: idm_user_3
         state: absent

3. 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 path_to_inventory_directory/inventory.file path_to_playbooks_directory/delete-users.yml

1. Connectez-vous à ipaserver en tant qu'administrateur :

   $ ssh administrator@server.idm.example.com
   Password:
   [admin@server /]$

2. Demande d'informations sur idm_user_1:

   $ ipa user-show idm_user_1
   ipa: ERROR: idm_user_1: user not found

   L'utilisateur nommé idm_user_1 n'existe pas dans IdM.

Procédure

1. Dans le coin supérieur droit, cliquez sur User name → Change password.

   Figure 5.1. Réinitialisation du mot de passe

   
2. Saisissez le mot de passe actuel et le nouveau mot de passe.

Procédure

1. Sélectionner Identité → Users.
2. Cliquez sur le nom de l'utilisateur à modifier.

3. Cliquez sur Actions → Reset password.

   Figure 5.2. Réinitialisation du mot de passe

   

4. Saisissez le nouveau mot de passe et cliquez sur Réinitialiser le mot de passe.

   Figure 5.3. Confirmation du nouveau mot de passe

   

Procédure

1. Générez un nouveau hachage de mot de passe à l'aide de la commande pwdhash. Par exemple :

   # pwdhash -D /etc/dirsrv/slapd-IDM-EXAMPLE-COM password
   {PBKDF2_SHA256}AAAgABU0bKhyjY53NcxY33ueoPjOUWtl4iyYN5uW...

   En spécifiant le chemin d'accès à la configuration du serveur d'annuaire, vous utilisez automatiquement le schéma de stockage du mot de passe défini dans l'attribut nsslapd-rootpwstoragescheme pour crypter le nouveau mot de passe.

2. Sur chaque serveur IdM de votre topologie, exécutez les étapes suivantes :

   1. Arrêter tous les services IdM installés sur le serveur :

      # ipactl stop

   2. Modifiez le fichier /etc/dirsrv/IDM-EXAMPLE-COM/dse.ldif et attribuez à l'attribut nsslapd-rootpw la valeur générée par la commande pwdhash:

      nsslapd-rootpw: {PBKDF2_SHA256}AAAgABU0bKhyjY53NcxY33ueoPjOUWtl4iyYN5uW...

   3. Démarrer tous les services IdM installés sur le serveur :

   # ipactl start

Procédure

1. Sur chaque serveur de gestion des identités (IdM) du domaine, effectuez les modifications suivantes :

   1. Entrez la commande ldapmodify pour modifier les entrées LDAP. Indiquez le nom du serveur IdM et le port 389, puis appuyez sur Entrée :

      $ ldapmodify -x -D "cn=Directory Manager" -W -h server.idm.example.com -p 389
      Enter LDAP Password:

   2. Saisissez le mot de passe du gestionnaire de répertoire.

   3. Saisissez le nom distinctif de l'entrée de synchronisation du mot de passe ipa_pwd_extop et appuyez sur Entrée :

      dn : cn=ipa_pwd_extop,cn=plugins,cn=config

   4. Spécifiez le type de modification modify et appuyez sur Entrée :

      changetype : modify

   5. Indiquez le type de modification que vous souhaitez que LDAP exécute et à quel attribut. Appuyez sur Entrée :

      ajouter : passSyncManagersDNs

   6. Spécifiez les comptes d'utilisateurs administratifs dans l'attribut passSyncManagersDNs. Cet attribut a plusieurs valeurs. Par exemple, pour accorder à l'utilisateur admin les pouvoirs de réinitialisation du mot de passe de Directory Manager :

      passSyncManagersDNs: \
      uid=admin,cn=users,cn=accounts,dc=example,dc=com

   7. Appuyez deux fois sur Enter pour arrêter la modification de l'entrée.

Procédure

1. Affichez le statut du compte utilisateur pour connaître le nombre d'échecs de connexion :

   $ ipa user-status example_user
   -----------------------
   Account disabled: False
   -----------------------
     Server: idm.example.com
     Failed logins: 8
     Last successful authentication: N/A
     Last failed authentication: 20220229080317Z
     Time now: 2022-02-29T08:04:46Z
   ----------------------------
   Number of entries returned 1
   ----------------------------

2. Affiche le nombre de tentatives de connexion autorisées pour un utilisateur donné :

   1. Se connecter à l'interface Web IdM en tant qu'administrateur IdM.
   2. Ouvrez l'onglet Identity → Users → Active users.

   

   1. Cliquez sur le nom de l'utilisateur pour ouvrir les paramètres de l'utilisateur.
   2. Dans la section Password policy, localisez l'élément Max failures.
3. Comparez le nombre d'échecs de connexion affiché dans la sortie de la commande ipa user-status avec le nombre de Max failures affiché dans l'interface Web de l'IdM. Si le nombre d'échecs de connexion est égal au nombre maximum de tentatives de connexion autorisées, le compte de l'utilisateur est verrouillé.

Procédure

1. Affiche les fonctions du plug-in de mot de passe actuellement activées :

   # ipa config-show | grep "Password plugin features"
     Password plugin features: AllowNThash, KDC:Disable Last Success

   La sortie montre que le plug-in KDC:Disable Last Success est activé. Le plug-in masque la dernière tentative d'authentification Kerberos réussie dans la sortie ipa user-status.

2. Ajouter le paramètre --ipaconfigstring=feature le paramètre pour chaque fonctionnalité de la commande ipa config-mod actuellement activée, à l'exception de KDC:Disable Last Success:

   # ipa config-mod --ipaconfigstring='AllowNThash'

   Cette commande n'active que le plug-in AllowNThash. Pour activer plusieurs fonctionnalités, spécifiez le paramètre --ipaconfigstring=feature séparément pour chaque fonctionnalité.

3. Redémarrer IdM :

   # ipactl restart

Procédure

1. Créez un fichier d'inventaire, par exemple inventory.file, et définissez le FQDN de votre serveur IdM dans la section [ipaserver]:

   [ipaserver]
   server.idm.example.com

2. Créez votre fichier playbook Ansible qui définit la politique de mot de passe dont vous voulez assurer la présence. Pour simplifier cette étape, copiez et modifiez l'exemple dans le fichier /usr/share/doc/ansible-freeipa/playbooks/pwpolicy/pwpolicy_present.yml:

   ---
   - name: Tests
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Ensure presence of pwpolicy for group ops
       ipapwpolicy:
         ipaadmin_password: "{{ ipaadmin_password }}"
         name: ops
         minlife: 7
         maxlife: 49
         history: 5
         priority: 1
         lockouttime: 300
         minlength: 8
         minclasses: 4
         maxfail: 3
         failinterval: 5

   Pour plus de détails sur la signification des différentes variables, voir Attributs de la politique de mot de passe.

3. Exécutez le manuel de jeu :

   $ ansible-playbook --vault-password-file=password_file -v -i path_to_inventory_directory/inventory.file path_to_playbooks_directory_/new_pwpolicy_present.yml

Procédure

1. Appliquer le contrôle du nom d'utilisateur à tous les nouveaux mots de passe proposés par les utilisateurs du groupe managers:

   $ ipa pwpolicy-mod --usercheck=True managers

   Note

   Si vous ne spécifiez pas le nom de la politique de mot de passe, la valeur par défaut global_policy est modifiée.

2. Définissez le nombre maximum de caractères identiques consécutifs à 2 dans la politique de mot de passe managers:

   $ ipa pwpolicy-mod --maxrepeat=2 managers

   Un mot de passe ne sera pas accepté s'il contient plus de 2 caractères identiques consécutifs. Par exemple, la combinaison eR873mUi111YJQ est inacceptable parce qu'elle contient trois 1consécutifs.

Vérification

1. Ajouter un utilisateur test nommé test_user:

   $ ipa user-add test_user
   First name: test
   Last name: user
   ----------------------------
   Added user "test_user"
   ----------------------------

2. Ajoutez l'utilisateur test au groupe managers:

   1. Dans l'interface Web IdM, cliquez sur Identité → Groupes → Groupes d'utilisateurs.
   2. Cliquez sur managers.
   3. Cliquez sur Add.
   4. Dans la page Add users into user group 'managers', vérifiez test_user.
   5. Cliquez sur la flèche > pour déplacer l'utilisateur dans la colonne Prospective.
   6. Cliquez sur Add.

3. Réinitialiser le mot de passe de l'utilisateur test :

   1. Aller à Identité → Utilisateurs.
   2. Cliquez sur test_user.
   3. Dans le menu Actions, cliquez sur Reset Password.
   4. Entrez un mot de passe temporaire pour l'utilisateur.

4. Sur la ligne de commande, essayez d'obtenir un ticket Kerberos (TGT) pour l'adresse test_user:

   $ kinit test_user

   1. Saisissez le mot de passe temporaire.

   2. Le système vous informe que vous devez modifier votre mot de passe. Saisissez un mot de passe qui contient le nom d'utilisateur test_user:

      Password expired. You must change it now.
      Enter new password:
      Enter it again:
      Password change rejected: Password not changed.
      Unspecified password quality failure while trying to change password.
      Please try again.

      Note

      Kerberos ne dispose pas d'une politique de signalement des erreurs de mot de passe très fine et, dans certains cas, ne fournit pas de raison claire pour laquelle un mot de passe a été rejeté.

   3. Le système vous informe que le mot de passe introduit a été rejeté. Introduisez un mot de passe contenant au moins trois caractères identiques successifs :

      Password change rejected: Password not changed.
      Unspecified password quality failure while trying to change password.
      Please try again.
      
      Enter new password:
      Enter it again:

   4. Le système vous informe que le mot de passe introduit a été rejeté. Saisissez un mot de passe qui répond aux critères de la politique de mot de passe managers:

      Password change rejected: Password not changed.
      Unspecified password quality failure while trying to change password.
      Please try again.
      
      Enter new password:
      Enter it again:

5. Voir le TGT :

   $ klist
   Ticket cache: KCM:0:33945
   Default principal: test_user@IDM.EXAMPLE.COM
   
   Valid starting       Expires              Service principal
   07/07/2021 12:44:44  07/08/2021 12:44:44  krbtgt@IDM.EXAMPLE.COM@IDM.EXAMPLE.COM

Procédure

1. Créez votre fichier Ansible playbook manager_pwpolicy_present.yml qui définit la politique de mot de passe dont vous voulez assurer la présence. Pour simplifier cette étape, copiez et modifiez l'exemple suivant :

   ---
   - name: Tests
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Ensure presence of usercheck and maxrepeat pwpolicy for group managers
       ipapwpolicy:
         ipaadmin_password: "{{ ipaadmin_password }}"
         name: managers
         usercheck: True
         maxrepeat: 2
         maxsequence: 3

2. Exécutez le manuel de jeu :

   $ ansible-playbook --vault-password-file=password_file -v -i path_to_inventory_directory/inventory.file path_to_playbooks_directory_/manager_pwpolicy_present.yml

Vérification

1. Ajouter un utilisateur test nommé test_user:

   $ ipa user-add test_user
   First name: test
   Last name: user
   ----------------------------
   Added user "test_user"
   ----------------------------

2. Ajoutez l'utilisateur test au groupe managers:

   1. Dans l'interface Web IdM, cliquez sur Identité → Groupes → Groupes d'utilisateurs.
   2. Cliquez sur managers.
   3. Cliquez sur Add.
   4. Dans la page Add users into user group 'managers', vérifiez test_user.
   5. Cliquez sur la flèche > pour déplacer l'utilisateur dans la colonne Prospective.
   6. Cliquez sur Add.

3. Réinitialiser le mot de passe de l'utilisateur test :

   1. Aller à Identité → Utilisateurs.
   2. Cliquez sur test_user.
   3. Dans le menu Actions, cliquez sur Reset Password.
   4. Entrez un mot de passe temporaire pour l'utilisateur.

4. Sur la ligne de commande, essayez d'obtenir un ticket Kerberos (TGT) pour l'adresse test_user:

   $ kinit test_user

   1. Saisissez le mot de passe temporaire.

   2. Le système vous informe que vous devez modifier votre mot de passe. Saisissez un mot de passe qui contient le nom d'utilisateur test_user:

      Password expired. You must change it now.
      Enter new password:
      Enter it again:
      Password change rejected: Password not changed.
      Unspecified password quality failure while trying to change password.
      Please try again.

      Note

      Kerberos ne dispose pas d'une politique de signalement des erreurs de mot de passe très fine et, dans certains cas, ne fournit pas de raison claire pour laquelle un mot de passe a été rejeté.

   3. Le système vous informe que le mot de passe introduit a été rejeté. Introduisez un mot de passe contenant au moins trois caractères identiques successifs :

      Password change rejected: Password not changed.
      Unspecified password quality failure while trying to change password.
      Please try again.
      
      Enter new password:
      Enter it again:

   4. Le système vous informe que le mot de passe saisi a été rejeté. Introduisez un mot de passe qui contient une séquence de caractères monotone de plus de 3 caractères. Des exemples de telles séquences sont 1234 et fedc:

      Password change rejected: Password not changed.
      Unspecified password quality failure while trying to change password.
      Please try again.
      
      Enter new password:
      Enter it again:

   5. Le système vous informe que le mot de passe introduit a été rejeté. Saisissez un mot de passe qui répond aux critères de la politique de mot de passe managers:

      Password change rejected: Password not changed.
      Unspecified password quality failure while trying to change password.
      Please try again.
      
      Enter new password:
      Enter it again:

5. Vérifiez que vous avez obtenu un TGT, ce qui n'est possible qu'après avoir introduit un mot de passe valide :

   $ klist
   Ticket cache: KCM:0:33945
   Default principal: test_user@IDM.EXAMPLE.COM
   
   Valid starting       Expires              Service principal
   07/07/2021 12:44:44  07/08/2021 12:44:44  krbtgt@IDM.EXAMPLE.COM@IDM.EXAMPLE.COM

Procédure

1. Mettez à jour le fichier de configuration epn.conf pour définir les options permettant à l'outil EPN d'avertir les utilisateurs de l'expiration prochaine de leur mot de passe.

   # vi /etc/ipa/epn.conf

2. Mettez à jour le site notify_ttls si nécessaire. Par défaut, les utilisateurs dont les mots de passe expirent dans 28, 14, 7, 3 et 1 jour(s) sont avertis.

   notify_ttls = 28, 14, 7, 3, 1

3. Configurez votre serveur SMTP et votre port :

   smtp_server = localhost
   smtp_port = 25

4. Indiquez l'adresse électronique à partir de laquelle la notification d'expiration du courrier électronique est envoyée. Les courriels non délivrés sont renvoyés à cette adresse.

   mail_from =admin-email@example.com

5. Enregistrez le fichier /etc/ipa/epn.conf.

6. Exécutez l'outil EPN en mode "dry-run" pour générer une liste des utilisateurs auxquels la notification par e-mail de l'expiration du mot de passe serait envoyée si vous exécutiez l'outil sans l'option --dry-run.

   ipa-epn --dry-run
   [
       {
        "uid": "user5",
        "cn": "user 5",
        "krbpasswordexpiration": "2020-04-17 15:51:53",
        "mail": "['user5@ipa.test']"
       }
   ]
   [
       {
        "uid": "user6",
        "cn": "user 6",
        "krbpasswordexpiration": "2020-12-17 15:51:53",
        "mail": "['user5@ipa.test']"
        }
   ]
   The IPA-EPN command was successful

   Note

   Si la liste des utilisateurs renvoyée est très importante et que vous exécutez l'outil sans l'option --dry-run, cela peut entraîner un problème avec votre serveur de messagerie.

7. Exécutez l'outil EPN sans l'option --dry-run pour envoyer des courriels d'expiration à la liste de tous les utilisateurs renvoyés lorsque vous avez exécuté l'outil EPN en mode "dry run" :

   ipa-epn
   [
     {
        "uid": "user5",
        "cn": "user 5",
        "krbpasswordexpiration": "2020-10-01 15:51:53",
        "mail": "['user5@ipa.test']"
     }
   ]
   [
     {
       "uid": "user6",
       "cn": "user 6",
       "krbpasswordexpiration": "2020-12-17 15:51:53",
       "mail": "['user5@ipa.test']"
     }
   ]
   The IPA-EPN command was successful

8. Vous pouvez ajouter EPN à n'importe quel système de surveillance et l'invoquer avec les options --from-nbdays et --to-nbdays pour déterminer combien de mots de passe d'utilisateurs vont expirer dans un délai spécifique :

   # ipa-epn --from-nbdays 8 --to-nbdays 12

   Note

   Si vous invoquez l'outil EPN avec les options --from-nbdays et --to-nbdays, il est automatiquement exécuté en mode "dry-run".

Procédure

1. Ouvrez le modèle de message EPN :

   # vi /etc/ipa/epn/expire_msg.template

2. Mettez à jour le texte du modèle si nécessaire.

   Hi {{ fullname }},
   
   Your password will expire on {{ expiration }}.
   
   Please change it as soon as possible.

   Vous pouvez utiliser les variables suivantes dans le modèle.

   • Identifiant de l'utilisateur : uid
   • Nom complet : nom complet
   • Prénom : prénom
   • Nom de famille : nom
   • Date d'expiration du mot de passe : expiration
3. Sauvegarder le fichier du modèle de message.

Procédure

1. Récupérer un ticket Kerberos en tant qu'IdM admin.

   [root@idmclient ~]# kinit admin

2. Ajouter la commande /usr/sbin/reboot à la base de données IdM des commandes sudo:

   [root@idmclient ~]# ipa sudocmd-add /usr/sbin/reboot
   -------------------------------------
   Added Sudo Command "/usr/sbin/reboot"
   -------------------------------------
     Sudo Command: /usr/sbin/reboot

3. Créez une règle sudo nommée idm_user_reboot:

   [root@idmclient ~]# ipa sudorule-add idm_user_reboot
   ---------------------------------
   Added Sudo Rule "idm_user_reboot"
   ---------------------------------
     Rule name: idm_user_reboot
     Enabled: TRUE

4. Ajoutez la commande /usr/sbin/reboot à la règle idm_user_reboot:

   [root@idmclient ~]# ipa sudorule-add-allow-command idm_user_reboot --sudocmds '/usr/sbin/reboot'
     Rule name: idm_user_reboot
     Enabled: TRUE
     Sudo Allow Commands: /usr/sbin/reboot
   -------------------------
   Number of members added 1
   -------------------------

5. Appliquer la règle idm_user_reboot à l'hôte IdM idmclient:

   [root@idmclient ~]# ipa sudorule-add-host idm_user_reboot --hosts idmclient.idm.example.com
   Rule name: idm_user_reboot
   Enabled: TRUE
   Hosts: idmclient.idm.example.com
   Sudo Allow Commands: /usr/sbin/reboot
   -------------------------
   Number of members added 1
   -------------------------

6. Ajoutez le compte idm_user à la règle idm_user_reboot:

   [root@idmclient ~]# ipa sudorule-add-user idm_user_reboot --users idm_user
   Rule name: idm_user_reboot
   Enabled: TRUE
   Users: idm_user
   Hosts: idmclient.idm.example.com
   Sudo Allow Commands: /usr/sbin/reboot
   -------------------------
   Number of members added 1
   -------------------------

7. Il est possible de définir la validité de la règle idm_user_reboot:

   1. Pour définir l'heure à laquelle une règle sudo commence à être valide, utilisez la commande ipa sudorule-mod sudo_rule_name avec l'option --setattr sudonotbefore=DATE option. La valeur de DATE doit suivre le format de yyyymmddHHMMSSZ, en spécifiant explicitement les secondes. Par exemple, pour définir le début de la validité de la règle idm_user_reboot au 31 décembre 2025 12:34:00, entrez :

      [root@idmclient ~]# ipa sudorule-mod idm_user_reboot --setattr sudonotbefore=20251231123400Z

   2. Pour définir l'heure à laquelle une règle sudo cesse d'être valide, utilisez l'option --setattr sudonotafter=DATE. Par exemple, pour fixer la fin de la validité de la règle idm_user_reboot au 31 décembre 2026 12:34:00, entrez :

      [root@idmclient ~]# ipa sudorule-mod idm_user_reboot --setattr sudonotafter=20261231123400Z

Verification steps

1. Connectez-vous à l'hôte idmclient en tant que compte idm_user.

2. Affiche les règles sudo que le compte idm_user est autorisé à appliquer.

   [idm_user@idmclient ~]$ sudo -l
   Matching Defaults entries for idm_user on idmclient:
       !visiblepw, always_set_home, match_group_by_gid, always_query_group_plugin,
       env_reset, env_keep="COLORS DISPLAY HOSTNAME HISTSIZE KDEDIR LS_COLORS",
       env_keep+="MAIL PS1 PS2 QTDIR USERNAME LANG LC_ADDRESS LC_CTYPE",
       env_keep+="LC_COLLATE LC_IDENTIFICATION LC_MEASUREMENT LC_MESSAGES",
       env_keep+="LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE",
       env_keep+="LC_TIME LC_ALL LANGUAGE LINGUAS _XKB_CHARSET XAUTHORITY KRB5CCNAME",
       secure_path=/sbin\:/bin\:/usr/sbin\:/usr/bin
   
   User idm_user may run the following commands on idmclient:
       (root) /usr/sbin/reboot

3. Redémarrez la machine en utilisant sudo. Saisissez le mot de passe de idm_user lorsque vous y êtes invité :

   [idm_user@idmclient ~]$ sudo /usr/sbin/reboot
   [sudo] password for idm_user:

1. Ajouter les utilisateurs ou groupes AD à un groupe IdM externe non-POSIX.
2. Ajouter le groupe IdM externe non-POSIX à un groupe IdM POSIX.

Procédure

1. Créer le groupe ad_users qui contient le groupe ad_users_external avec le membre administrator@ad-domain:

   1. Optional: Créez ou sélectionnez un groupe correspondant dans le domaine AD à utiliser pour gérer les utilisateurs AD dans le domaine IdM. Vous pouvez utiliser plusieurs groupes AD et les ajouter à différents groupes du côté IdM.

   2. Créez le groupe ad_users_external et indiquer qu'il contient des membres extérieurs au domaine IdM en ajoutant l'option --external:

      [root@ipaserver ~]# ipa group-add --desc='AD users external map' ad_users_external --external
      -------------------------------
      Added group "ad_users_external"
      -------------------------------
        Group name: ad_users_external
        Description: AD users external map

      Note

      Assurez-vous que le groupe externe que vous spécifiez ici est un groupe de sécurité AD avec une portée de groupe global ou universal comme défini dans le document sur les groupes de sécurité Active Directory. Par exemple, les groupes de sécurité AD Domain users ou Domain admins ne peuvent pas être utilisés car leur périmètre de groupe est domain local.

   3. Créez le groupe ad_users:

      [root@ipaserver ~]# ipa group-add --desc='AD users' ad_users
      ----------------------
      Added group "ad_users"
      ----------------------
        Group name: ad_users
        Description: AD users
        GID: 129600004

   4. Ajoutez l'utilisateur AD administrator@ad-domain.com à ad_users_external en tant que membre externe :

      [root@ipaserver ~]# ipa group-add-member ad_users_external --external "administrator@ad-domain.com"
       [member user]:
       [member group]:
        Group name: ad_users_external
        Description: AD users external map
        External member: S-1-5-21-3655990580-1375374850-1633065477-513
      -------------------------
      Number of members added 1
      -------------------------

      L'utilisateur AD doit être identifié par un nom complet, tel que DOMAIN\user_name ou user_name@DOMAIN. L'identité AD est ensuite mappée au SID AD de l'utilisateur. Il en va de même pour l'ajout de groupes AD.

   5. Ajoutez ad_users_external à ad_users en tant que membre :

      [root@ipaserver ~]# ipa group-add-member ad_users --groups ad_users_external
        Group name: ad_users
        Description: AD users
        GID: 129600004
        Member groups: ad_users_external
      -------------------------
      Number of members added 1
      -------------------------

2. Accordez aux membres de ad_users la permission d'exécuter /usr/sbin/reboot sur l'hôte idmclient:

   1. Ajouter la commande /usr/sbin/reboot à la base de données IdM des commandes sudo:

      [root@idmclient ~]# ipa sudocmd-add /usr/sbin/reboot
      -------------------------------------
      Added Sudo Command "/usr/sbin/reboot"
      -------------------------------------
        Sudo Command: /usr/sbin/reboot

   2. Créez une règle sudo nommée ad_users_reboot:

      [root@idmclient ~]# ipa sudorule-add ad_users_reboot
      ---------------------------------
      Added Sudo Rule "ad_users_reboot"
      ---------------------------------
        Rule name: ad_users_reboot
        Enabled: True

   3. Ajoutez la commande /usr/sbin/reboot à la règle ad_users_reboot:

      [root@idmclient ~]# ipa sudorule-add-allow-command ad_users_reboot --sudocmds '/usr/sbin/reboot'
        Rule name: ad_users_reboot
        Enabled: True
        Sudo Allow Commands: /usr/sbin/reboot
      -------------------------
      Number of members added 1
      -------------------------

   4. Appliquer la règle ad_users_reboot à l'hôte IdM idmclient:

      [root@idmclient ~]# ipa sudorule-add-host ad_users_reboot --hosts idmclient.idm.example.com
      Rule name: ad_users_reboot
      Enabled: True
      Hosts: idmclient.idm.example.com
      Sudo Allow Commands: /usr/sbin/reboot
      -------------------------
      Number of members added 1
      -------------------------

   5. Ajoutez le groupe ad_users à la règle ad_users_reboot:

      [root@idmclient ~]# ipa sudorule-add-user ad_users_reboot --groups ad_users
      Rule name: ad_users_reboot
      Enabled: TRUE
      User Groups: ad_users
      Hosts: idmclient.idm.example.com
      Sudo Allow Commands: /usr/sbin/reboot
      -------------------------
      Number of members added 1
      -------------------------

Verification steps

1. Connectez-vous à l'hôte idmclient en tant que administrator@ad-domain.com, un membre indirect du groupe ad_users:

   $ ssh administrator@ad-domain.com@ipaclient
   Password:

2. Optionnellement, afficher les commandes sudo que administrator@ad-domain.com est autorisé à exécuter :

   [administrator@ad-domain.com@idmclient ~]$ sudo -l
   Matching Defaults entries for administrator@ad-domain.com on idmclient:
       !visiblepw, always_set_home, match_group_by_gid, always_query_group_plugin,
       env_reset, env_keep="COLORS DISPLAY HOSTNAME HISTSIZE KDEDIR LS_COLORS",
       env_keep+="MAIL PS1 PS2 QTDIR USERNAME LANG LC_ADDRESS LC_CTYPE",
       env_keep+="LC_COLLATE LC_IDENTIFICATION LC_MEASUREMENT LC_MESSAGES",
       env_keep+="LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE",
       env_keep+="LC_TIME LC_ALL LANGUAGE LINGUAS _XKB_CHARSET XAUTHORITY KRB5CCNAME",
       secure_path=/sbin\:/bin\:/usr/sbin\:/usr/bin
   
   User administrator@ad-domain.com may run the following commands on idmclient:
       (root) /usr/sbin/reboot

3. Redémarrez la machine en utilisant sudo. Saisissez le mot de passe de administrator@ad-domain.com lorsque vous y êtes invité :

   [administrator@ad-domain.com@idmclient ~]$ sudo /usr/sbin/reboot
   [sudo] password for administrator@ad-domain.com:

Procédure

1. Ajouter la commande /usr/sbin/reboot à la base de données IdM des commandes sudo:

   1. Naviguez vers Policy → Sudo → Sudo Commands.
   2. Cliquez sur Add dans le coin supérieur droit pour ouvrir la boîte de dialogue Add sudo command.

   3. Saisissez la commande que vous souhaitez que l'utilisateur puisse exécuter en utilisant sudo: /usr/sbin/reboot.

      Figure 8.1. Ajout de la commande sudo de l'IdM

      
   4. Cliquez sur Add.

2. Utilisez la nouvelle entrée de commande sudo pour créer une règle sudo permettant à idm_user de redémarrer la machine idmclient:

   1. Naviguez vers Policy → Sudo → Sudo rules.
   2. Cliquez sur Add dans le coin supérieur droit pour ouvrir la boîte de dialogue Add sudo rule.
   3. Saisissez le nom de la règle sudo: idm_user_reboot.
   4. Cliquez sur Add and Edit.

   5. Spécifiez l'utilisateur :

      1. Dans la section Who, cochez le bouton radio Specified Users and Groups.
      2. Dans la sous-section User category the rule applies to, cliquez sur Add pour ouvrir la boîte de dialogue Add users into sudo rule "idm_user_reboot".
      3. Dans la boîte de dialogue Add users into sudo rule "idm_user_reboot", dans la colonne Available, cochez la case idm_user et déplacez-la dans la colonne Prospective.
      4. Cliquez sur Add.

   6. Spécifiez l'hôte :

      1. Dans la section Access this host, cochez le bouton radio Specified Hosts and Groups.
      2. Dans la sous-section Host category this rule applies to, cliquez sur Add pour ouvrir la boîte de dialogue Add hosts into sudo rule "idm_user_reboot".
      3. Dans la boîte de dialogue Add hosts into sudo rule "idm_user_reboot", dans la colonne Available, cochez la case idmclient.idm.example.com et déplacez-la dans la colonne Prospective.
      4. Cliquez sur Add.

   7. Spécifiez les commandes :

      1. Dans la sous-section Command category the rule applies to de la section Run Commands, cochez le bouton radio Specified Commands and Groups.
      2. Dans la sous-section Sudo Allow Commands, cliquez sur Add pour ouvrir la boîte de dialogue Add allow sudo commands into sudo rule "idm_user_reboot".
      3. Dans la boîte de dialogue Add allow sudo commands into sudo rule "idm_user_reboot", dans la colonne Available, cochez la case /usr/sbin/reboot et déplacez-la dans la colonne Prospective.
      4. Cliquez sur Add pour revenir à la page idm_sudo_reboot.

      Figure 8.2. Ajout d'une règle sudo à l'IdM

      
   8. Cliquez sur Save dans le coin supérieur gauche.

Verification steps

1. Connectez-vous à idmclient en tant que idm_user.

2. Redémarrez la machine en utilisant sudo. Saisissez le mot de passe de idm_user lorsque vous y êtes invité :

   $ sudo /usr/sbin/reboot
   [sudo] password for idm_user:

Procédure

1. Récupérer un ticket Kerberos en tant qu'IdM admin.

   [root@idmclient ~]# kinit admin

2. Ajouter la commande /opt/third-party-app/bin/report à la base de données IdM des commandes sudo:

   [root@idmclient ~]# ipa sudocmd-add /opt/third-party-app/bin/report
   ----------------------------------------------------
   Added Sudo Command "/opt/third-party-app/bin/report"
   ----------------------------------------------------
     Sudo Command: /opt/third-party-app/bin/report

3. Créez une règle sudo nommée run_third-party-app_report:

   [root@idmclient ~]# ipa sudorule-add run_third-party-app_report
   --------------------------------------------
   Added Sudo Rule "run_third-party-app_report"
   --------------------------------------------
     Rule name: run_third-party-app_report
     Enabled: TRUE

4. Utilisez l'option --users=<user> pour spécifier l'utilisateur RunAs pour la commande sudorule-add-runasuser:

   [root@idmclient ~]# ipa sudorule-add-runasuser run_third-party-app_report --users=thirdpartyapp
     Rule name: run_third-party-app_report
     Enabled: TRUE
     RunAs External User: thirdpartyapp
   -------------------------
   Number of members added 1
   -------------------------

   L'utilisateur (ou le groupe spécifié avec l'option --groups=* ) peut être externe à IdM, comme un compte de service local ou un utilisateur Active Directory. N'ajoutez pas de préfixe % pour les noms de groupes.

5. Ajoutez la commande /opt/third-party-app/bin/report à la règle run_third-party-app_report:

   [root@idmclient ~]# ipa sudorule-add-allow-command run_third-party-app_report --sudocmds '/opt/third-party-app/bin/report'
   Rule name: run_third-party-app_report
   Enabled: TRUE
   Sudo Allow Commands: /opt/third-party-app/bin/report
   RunAs External User: thirdpartyapp
   -------------------------
   Number of members added 1
   -------------------------

6. Appliquer la règle run_third-party-app_report à l'hôte IdM idmclient:

   [root@idmclient ~]# ipa sudorule-add-host run_third-party-app_report --hosts idmclient.idm.example.com
   Rule name: run_third-party-app_report
   Enabled: TRUE
   Hosts: idmclient.idm.example.com
   Sudo Allow Commands: /opt/third-party-app/bin/report
   RunAs External User: thirdpartyapp
   -------------------------
   Number of members added 1
   -------------------------

7. Ajoutez le compte idm_user à la règle run_third-party-app_report:

   [root@idmclient ~]# ipa sudorule-add-user run_third-party-app_report --users idm_user
   Rule name: run_third-party-app_report
   Enabled: TRUE
   Users: idm_user
   Hosts: idmclient.idm.example.com
   Sudo Allow Commands: /opt/third-party-app/bin/report
   RunAs External User: thirdpartyapp
   -------------------------
   Number of members added 1

Verification steps

1. Connectez-vous à l'hôte idmclient en tant que compte idm_user.

2. Testez la nouvelle règle sudo :

   1. Affiche les règles sudo que le compte idm_user est autorisé à appliquer.

      [idm_user@idmclient ~]$ sudo -l
      Matching Defaults entries for idm_user@idm.example.com on idmclient:
          !visiblepw, always_set_home, match_group_by_gid, always_query_group_plugin,
          env_reset, env_keep="COLORS DISPLAY HOSTNAME HISTSIZE KDEDIR LS_COLORS",
          env_keep+="MAIL PS1 PS2 QTDIR USERNAME LANG LC_ADDRESS LC_CTYPE",
          env_keep+="LC_COLLATE LC_IDENTIFICATION LC_MEASUREMENT LC_MESSAGES",
          env_keep+="LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE",
          env_keep+="LC_TIME LC_ALL LANGUAGE LINGUAS _XKB_CHARSET XAUTHORITY KRB5CCNAME",
          secure_path=/sbin\:/bin\:/usr/sbin\:/usr/bin
      
      User idm_user@idm.example.com may run the following commands on idmclient:
          (thirdpartyapp) /opt/third-party-app/bin/report

   2. Exécutez la commande report en tant que compte de service thirdpartyapp.

      [idm_user@idmclient ~]$ sudo -u thirdpartyapp /opt/third-party-app/bin/report
      [sudo] password for idm_user@idm.example.com:
      Executing report...
      Report successful.

Procédure

1. Ajouter la commande /opt/third-party-app/bin/report à la base de données IdM des commandes sudo:

   1. Naviguez vers Policy → Sudo → Sudo Commands.
   2. Cliquez sur Add dans le coin supérieur droit pour ouvrir la boîte de dialogue Add sudo command.

   3. Entrez la commande : /opt/third-party-app/bin/report.

      
   4. Cliquez sur Add.

2. Utilisez l'entrée de commande new sudo pour créer la nouvelle règle sudo:

   1. Naviguez vers Policy → Sudo → Sudo rules.
   2. Cliquez sur Add dans le coin supérieur droit pour ouvrir la boîte de dialogue Add sudo rule.

   3. Saisissez le nom de la règle sudo: run_third-party-app_report.

      
   4. Cliquez sur Add and Edit.

   5. Spécifiez l'utilisateur :

      1. Dans la section Who, cochez le bouton radio Specified Users and Groups.
      2. Dans la sous-section User category the rule applies to, cliquez sur Add pour ouvrir la boîte de dialogue Add users into sudo rule "run_third-party-app_report".

      3. Dans la boîte de dialogue Add users into sudo rule "run_third-party-app_report", dans la colonne Available, cochez la case idm_user et déplacez-la dans la colonne Prospective.

         
      4. Cliquez sur Add.

   6. Spécifiez l'hôte :

      1. Dans la section Access this host, cochez le bouton radio Specified Hosts and Groups.
      2. Dans la sous-section Host category this rule applies to, cliquez sur Add pour ouvrir la boîte de dialogue Add hosts into sudo rule "run_third-party-app_report".

      3. Dans la boîte de dialogue Add hosts into sudo rule "run_third-party-app_report", dans la colonne Available, cochez la case idmclient.idm.example.com et déplacez-la dans la colonne Prospective.

         
      4. Cliquez sur Add.

   7. Spécifiez les commandes :

      1. Dans la sous-section Command category the rule applies to de la section Run Commands, cochez le bouton radio Specified Commands and Groups.
      2. Dans la sous-section Sudo Allow Commands, cliquez sur Add pour ouvrir la boîte de dialogue Add allow sudo commands into sudo rule "run_third-party-app_report".

      3. Dans la boîte de dialogue Add allow sudo commands into sudo rule "run_third-party-app_report", dans la colonne Available, cochez la case /opt/third-party-app/bin/report et déplacez-la dans la colonne Prospective.

         
      4. Cliquez sur Add pour revenir à la page run_third-party-app_report.

   8. Spécifiez l'utilisateur RunAs :

      1. Dans la section As Whom, cochez le bouton radio Specified Users and Groups.
      2. Dans la sous-section RunAs Users, cliquez sur Add pour ouvrir la boîte de dialogue Add RunAs users into sudo rule "run_third-party-app_report".

      3. Dans la boîte de dialogue Add RunAs users into sudo rule "run_third-party-app_report", saisissez le compte de service thirdpartyapp dans la case External et déplacez-le dans la colonne Prospective.

         
      4. Cliquez sur Add pour revenir à la page run_third-party-app_report.
   9. Cliquez sur Save dans le coin supérieur gauche.

Verification steps

1. Connectez-vous à l'hôte idmclient en tant que compte idm_user.

2. Testez la nouvelle règle sudo :

   1. Affiche les règles sudo que le compte idm_user est autorisé à appliquer.

      [idm_user@idmclient ~]$ sudo -l
      Matching Defaults entries for idm_user@idm.example.com on idmclient:
          !visiblepw, always_set_home, match_group_by_gid, always_query_group_plugin,
          env_reset, env_keep="COLORS DISPLAY HOSTNAME HISTSIZE KDEDIR LS_COLORS",
          env_keep+="MAIL PS1 PS2 QTDIR USERNAME LANG LC_ADDRESS LC_CTYPE",
          env_keep+="LC_COLLATE LC_IDENTIFICATION LC_MEASUREMENT LC_MESSAGES",
          env_keep+="LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE",
          env_keep+="LC_TIME LC_ALL LANGUAGE LINGUAS _XKB_CHARSET XAUTHORITY KRB5CCNAME",
          secure_path=/sbin\:/bin\:/usr/sbin\:/usr/bin
      
      User idm_user@idm.example.com may run the following commands on idmclient:
          (thirdpartyapp) /opt/third-party-app/bin/report

   2. Exécutez la commande report en tant que compte de service thirdpartyapp.

      [idm_user@idmclient ~]$ sudo -u thirdpartyapp /opt/third-party-app/bin/report
      [sudo] password for idm_user@idm.example.com:
      Executing report...
      Report successful.

Procédure

1. Ouvrez le fichier de configuration /etc/sssd/sssd.conf.

2. Ajoutez l'entrée suivante à la section [domain/<domain_name>] l'entrée suivante.

   [domain/<domain_name>]
   pam_gssapi_services = sudo, sudo-i

3. Enregistrez et fermez le fichier /etc/sssd/sssd.conf.

4. Redémarrez le service SSSD pour charger les modifications de configuration.

   [root@idmclient ~]# systemctl restart sssd

5. Si vous utilisez RHEL 9.2 ou une version ultérieure :

   1. [Facultatif] Déterminez si vous avez sélectionné le profil sssd authselect :

      # authselect current
      Profile ID: sssd

      Le résultat indique que le profil sssd authselect est sélectionné.

   2. Si le profil sssd authselect est sélectionné, activez l'authentification GSSAPI :

      # authselect enable-feature with-gssapi

   3. Si le profil sssd authselect n'est pas sélectionné, sélectionnez-le et activez l'authentification GSSAPI :

      # authselect select sssd with-gssapi

6. Si vous utilisez RHEL 9.1 ou une version antérieure :

   1. Ouvrez le fichier de configuration PAM de /etc/pam.d/sudo.

   2. Ajoutez l'entrée suivante comme première ligne de la section auth dans le fichier /etc/pam.d/sudo.

      #%PAM-1.0
      auth sufficient pam_sss_gss.so
      auth       include      system-auth
      account    include      system-auth
      password   include      system-auth
      session    include      system-auth

   3. Enregistrez et fermez le fichier /etc/pam.d/sudo.

Verification steps

1. Connectez-vous à l'hôte en tant que compte idm_user.

   [root@idm-client ~]# ssh -l idm_user@idm.example.com localhost
   idm_user@idm.example.com's password:

2. Vérifiez que vous disposez d'un ticket d'attribution de tickets en tant que compte idm_user.

   [idmuser@idmclient ~]$ klist
   Ticket cache: KCM:1366201107
   Default principal: idm_user@IDM.EXAMPLE.COM
   
   Valid starting       Expires              Service principal
   01/08/2021 09:11:48  01/08/2021 19:11:48  krbtgt/IDM.EXAMPLE.COM@IDM.EXAMPLE.COM
   	renew until 01/15/2021 09:11:44

3. (Optional) Si vous ne disposez pas d'informations d'identification Kerberos pour le compte idm_user, détruisez vos informations d'identification Kerberos actuelles et demandez les informations correctes.

   [idm_user@idmclient ~]$ kdestroy -A
   
   [idm_user@idmclient ~]$ kinit idm_user@IDM.EXAMPLE.COM
   Password for idm_user@idm.example.com:

4. Redémarrez la machine à l'aide de sudo, sans spécifier de mot de passe.

   [idm_user@idmclient ~]$ sudo /usr/sbin/reboot

Procédure

1. Ouvrez le fichier de configuration /etc/sssd/sssd.conf.

2. Ajoutez les entrées suivantes à la section [domain/<domain_name>] les entrées suivantes.

   [domain/<domain_name>]
   pam_gssapi_services = sudo, sudo-i
   pam_gssapi_indicators_map = sudo:pkinit, sudo-i:pkinit

3. Enregistrez et fermez le fichier /etc/sssd/sssd.conf.

4. Redémarrez le service SSSD pour charger les modifications de configuration.

   [root@idmclient ~]# systemctl restart sssd

5. Ouvrez le fichier de configuration PAM de /etc/pam.d/sudo.

6. Ajoutez l'entrée suivante comme première ligne de la section auth dans le fichier /etc/pam.d/sudo.

   #%PAM-1.0
   auth sufficient pam_sss_gss.so
   auth       include      system-auth
   account    include      system-auth
   password   include      system-auth
   session    include      system-auth

7. Enregistrez et fermez le fichier /etc/pam.d/sudo.
8. Ouvrez le fichier de configuration PAM de /etc/pam.d/sudo-i.

9. Ajoutez l'entrée suivante comme première ligne de la section auth dans le fichier /etc/pam.d/sudo-i.

   #%PAM-1.0
   auth sufficient pam_sss_gss.so
   auth       include      sudo
   account    include      sudo
   password   include      sudo
   session    optional     pam_keyinit.so force revoke
   session    include      sudo

10. Enregistrez et fermez le fichier /etc/pam.d/sudo-i.

Verification steps

1. Connectez-vous à l'hôte en tant que compte idm_user et authentifiez-vous à l'aide d'une carte à puce.

   [root@idmclient ~]# ssh -l idm_user@idm.example.com localhost
   PIN for smart_card

2. Vérifiez que vous disposez d'un ticket d'attribution de billets en tant qu'utilisateur de la carte à puce.

   [idm_user@idmclient ~]$ klist
   Ticket cache: KEYRING:persistent:1358900015:krb_cache_TObtNMd
   Default principal: idm_user@IDM.EXAMPLE.COM
   
   Valid starting       Expires              Service principal
   02/15/2021 16:29:48  02/16/2021 02:29:48  krbtgt/IDM.EXAMPLE.COM@IDM.EXAMPLE.COM
   	renew until 02/22/2021 16:29:44

3. Affiche les règles sudo que le compte idm_user est autorisé à appliquer.

   [idm_user@idmclient ~]$ sudo -l
   Matching Defaults entries for idmuser on idmclient:
       !visiblepw, always_set_home, match_group_by_gid, always_query_group_plugin,
       env_reset, env_keep="COLORS DISPLAY HOSTNAME HISTSIZE KDEDIR LS_COLORS",
       env_keep+="MAIL PS1 PS2 QTDIR USERNAME LANG LC_ADDRESS LC_CTYPE",
       env_keep+="LC_COLLATE LC_IDENTIFICATION LC_MEASUREMENT LC_MESSAGES",
       env_keep+="LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE",
       env_keep+="LC_TIME LC_ALL LANGUAGE LINGUAS _XKB_CHARSET XAUTHORITY KRB5CCNAME",
       secure_path=/sbin\:/bin\:/usr/sbin\:/usr/bin
   
   User idm_user may run the following commands on idmclient:
       (root) /usr/sbin/reboot

4. Redémarrez la machine à l'aide de sudo, sans spécifier de mot de passe.

   [idm_user@idmclient ~]$ sudo /usr/sbin/reboot

Procédure

1. Créez un fichier d'inventaire, par exemple inventory.file, et définissez-y ipaservers:

   [ipaservers]
   server.idm.example.com

2. Ajouter une ou plusieurs commandes sudo:

   1. Créer un playbook Ansible ensure-reboot-sudocmd-is-present.yml qui assure la présence de la commande /usr/sbin/reboot dans la base de données IdM des commandes sudo. Pour simplifier cette étape, vous pouvez copier et modifier l'exemple dans le fichier /usr/share/doc/ansible-freeipa/playbooks/sudocmd/ensure-sudocmd-is-present.yml:

      ---
      - name: Playbook to manage sudo command
        hosts: ipaserver
      
        vars_files:
        - /home/user_name/MyPlaybooks/secret.yml
        tasks:
        # Ensure sudo command is present
        - ipasudocmd:
            ipaadmin_password: "{{ ipaadmin_password }}"
            name: /usr/sbin/reboot
            state: present

   2. Exécutez le manuel de jeu :

      $ ansible-playbook --vault-password-file=password_file -v -i path_to_inventory_directory/inventory.file path_to_playbooks_directory/ensure-reboot-sudocmd-is-present.yml

3. Créez une règle sudo qui fait référence aux commandes :

   1. Créez un playbook Ansible ensure-sudorule-for-idmuser-on-idmclient-is-present.yml qui utilise l'entrée de commande sudo pour s'assurer de la présence d'une règle sudo. La règle sudo permet à idm_user de redémarrer la machine idmclient. Pour simplifier cette étape, vous pouvez copier et modifier l'exemple dans le fichier /usr/share/doc/ansible-freeipa/playbooks/sudorule/ensure-sudorule-is-present.yml:

      ---
      - name: Tests
        hosts: ipaserver
      
        vars_files:
        - /home/user_name/MyPlaybooks/secret.yml
        tasks:
        # Ensure a sudorule is present granting idm_user the permission to run /usr/sbin/reboot on idmclient
        - ipasudorule:
            ipaadmin_password: "{{ ipaadmin_password }}"
            name: idm_user_reboot
            description: A test sudo rule.
            allow_sudocmd: /usr/sbin/reboot
            host: idmclient.idm.example.com
            user: idm_user
            state: present

   2. Exécutez le manuel de jeu :

      $ ansible-playbook -v -i path_to_inventory_directory/inventory.file path_to_playbooks_directory/ensure-sudorule-for-idmuser-on-idmclient-is-present.yml

1. Connectez-vous à idmclient en tant que idm_user.

2. Redémarrez la machine en utilisant sudo. Saisissez le mot de passe de idm_user lorsque vous y êtes invité :

   $ sudo /usr/sbin/reboot
   [sudo] password for idm_user:

Procédure

1. Dans une ligne de commande, saisissez l'instruction LDAP Data Interchange Format (LDIF) après la commande ldapmodify.

   Exemple 9.1. Modifier le numéro de téléphone d'un testuser

   # ldapmodify -Y GSSAPI -H ldap://server.example.com
   dn: uid=testuser,cn=users,cn=accounts,dc=example,dc=com
   changetype: modify
   replace: telephoneNumber
   telephonenumber: 88888888

   Notez que vous devez obtenir un ticket Kerberos pour utiliser l'option -Y.

2. Appuyez sur Ctlr D pour quitter le mode interactif.

3. Vous pouvez également fournir un fichier LDIF après la commande ldapmodify:

   Exemple 9.2. La commande ldapmodify permet de lire les données de modification d'un fichier LDIF

   # ldapmodify -Y GSSAPI -H ldap://server.example.com -f ~/example.ldif

Procédure

1. Se connecter en tant qu'utilisateur IdM avec un rôle de préservation des utilisateurs :

   kinit admin

2. Entrez dans la commande ldapmodify et indiquez Generic Security Services API (GSSAPI) comme mécanisme SASL (Simple Authentication and Security Layer) à utiliser pour l'authentification :

   # ldapmodify -Y GSSAPI
   SASL/GSSAPI authentication started
   SASL username: admin@IDM.EXAMPLE.COM
   SASL SSF: 256
   SASL data security layer installed.

3. Saisissez l'adresse dn de l'utilisateur que vous souhaitez préserver :

   dn : uid=user1,cn=users,cn=accounts,dc=idm,dc=example,dc=com

4. Saisissez modrdn comme type de modification à effectuer :

   changetype : modrdn

5. Spécifiez l'adresse newrdn pour l'utilisateur :

   newrdn : uid=user1

6. Indiquez que vous souhaitez préserver l'utilisateur :

   supprimeroldrdn : 0

7. Spécifiez le site new superior DN:

   newsuperior : cn=deleted users,cn=accounts,cn=provisioning,dc=idm,dc=example,dc=com

   La préservation d'un utilisateur déplace l'entrée vers un nouvel emplacement dans l'arborescence des informations de répertoire (DIT). C'est pourquoi vous devez spécifier le DN de la nouvelle entrée parent comme nouveau DN supérieur.

8. Appuyez à nouveau sur Enter pour confirmer la fin de l'entrée :

   [Enter]
   
   modifying rdn of entry "uid=user1,cn=users,cn=accounts,dc=idm,dc=example,dc=com"

9. Quittez la connexion en utilisant Ctrl C .

Procédure

1. Se connecter en tant qu'administrateur IdM :

   kinit admin

2. Créez un utilisateur nommé provisionator avec les privilèges d'ajouter des utilisateurs de scène.

   1. Ajouter le compte utilisateur du provisionneur :

   ipa user-add provisionator --first=provisioning --last=account --password

   1. Accorder à l'utilisateur du provisionneur les privilèges requis.

      1. Créez un rôle personnalisé, System Provisioning, pour gérer l'ajout d'utilisateurs de l'étape :

         $ ipa role-add --desc \N- "Responsable de l'approvisionnement des utilisateurs de l'étape\N" \N- "Provisionnement du système\N"

      2. Ajoutez le privilège Stage User Provisioning au rôle. Ce privilège permet d'ajouter des utilisateurs de scène :

         $ ipa role-add-privilege \N "System Provisioning" --privileges=\N "Stage User Provisioning" $ ipa role-add-privilege \N "System Provisioning" --privileges=\N "Stage User Provisioning"

      3. Ajouter l'utilisateur du provisionneur au rôle :

         $ ipa role-add-member --users=provisionator "System Provisioning"

      4. Vérifier que le provisionneur existe dans IdM :

      $ ipa user-find provisionator --all --raw
      --------------
      1 user matched
      --------------
        dn: uid=provisionator,cn=users,cn=accounts,dc=idm,dc=example,dc=com
        uid: provisionator
        [...]

3. Créez un utilisateur, activator, avec les privilèges nécessaires pour gérer les comptes d'utilisateurs.

   1. Ajouter le compte utilisateur de l'activateur :

      $ ipa user-add activator --first=activation --last=account --password

   2. Accordez à l'utilisateur de l'activateur les privilèges requis en ajoutant l'utilisateur au rôle par défaut User Administrator:

      $ ipa role-add-member --users=activator "User Administrator"

4. Créer un groupe d'utilisateurs pour les comptes d'application :

   ipa group-add application-accounts

5. Mettez à jour la politique de mot de passe pour le groupe. La politique suivante empêche l'expiration du mot de passe et le verrouillage du compte, mais compense les risques potentiels en exigeant des mots de passe complexes :

   $ ipa pwpolicy-add application-accounts --maxlife=10000 --minlife=0 --history=0 --minclasses=4 --minlength=8 --priority=1 --maxfail=0 --failinterval=1 --lockouttime=0

6. (Facultatif) Vérifier que la politique de mot de passe existe dans IdM :

   $ ipa pwpolicy-show application-accounts
     Group: application-accounts
     Max lifetime (days): 10000
     Min lifetime (hours): 0
     History size: 0
   [...]

7. Ajoutez les comptes de provisionnement et d'activation au groupe des comptes d'application :

   $ ipa group-add-member application-accounts --users={provisionator,activator}

8. Modifier les mots de passe des comptes utilisateurs :

   $ kpasswd provisionator
   $ kpasswd activator

   La modification des mots de passe est nécessaire car les mots de passe des nouveaux utilisateurs de l'IdM expirent immédiatement.

Procédure

1. Générer un fichier keytab pour le compte d'activation :

   # ipa-getkeytab -s server.idm.example.com -p "activator" -k /etc/krb5.ipa-activation.keytab

   Si vous souhaitez activer le processus d'activation sur plusieurs serveurs IdM, générez le fichier keytab sur un seul serveur. Copiez ensuite le fichier keytab sur les autres serveurs.

2. Créez un script, /usr/local/sbin/ipa-activate-all, avec le contenu suivant pour activer tous les utilisateurs :

   #!/bin/bash
   
   kinit -k -i activator
   
   ipa stageuser-find --all --raw | grep "  uid:" | cut -d ":" -f 2 | while read uid; do ipa stageuser-activate ${uid}; done

3. Modifiez les autorisations et la propriété du script ipa-activate-all pour le rendre exécutable :

   # chmod 755 /usr/local/sbin/ipa-activate-all
   # chown root:root /usr/local/sbin/ipa-activate-all

4. Créez un fichier d'unité systemd, /etc/systemd/system/ipa-activate-all.service, avec le contenu suivant :

   [Unit]
   Description=Scan IdM every minute for any stage users that must be activated
   
   [Service]
   Environment=KRB5_CLIENT_KTNAME=/etc/krb5.ipa-activation.keytab
   Environment=KRB5CCNAME=FILE:/tmp/krb5cc_ipa-activate-all
   ExecStart=/usr/local/sbin/ipa-activate-all

5. Créez un timer systemd, /etc/systemd/system/ipa-activate-all.timer, avec le contenu suivant :

   [Unit]
   Description=Scan IdM every minute for any stage users that must be activated
   
   [Timer]
   OnBootSec=15min
   OnUnitActiveSec=1min
   
   [Install]
   WantedBy=multi-user.target

6. Recharger la nouvelle configuration :

   # systemctl daemon-reload

7. Activer ipa-activate-all.timer:

   # systemctl enable ipa-activate-all.timer

8. Démarrer ipa-activate-all.timer:

   # systemctl start ipa-activate-all.timer

9. (Facultatif) Vérifiez que le démon ipa-activate-all.timer est en cours d'exécution :

   # systemctl status ipa-activate-all.timer
   ● ipa-activate-all.timer - Scan IdM every minute for any stage users that must be activated
      Loaded: loaded (/etc/systemd/system/ipa-activate-all.timer; enabled; vendor preset: disabled)
      Active: active (waiting) since Wed 2020-06-10 16:34:55 CEST; 15s ago
     Trigger: Wed 2020-06-10 16:35:55 CEST; 44s left
   
   Jun 10 16:34:55 server.idm.example.com systemd[1]: Started Scan IdM every minute for any stage users that must be activated.

Procédure

1. Sur le serveur externe, créez un fichier LDIF contenant des informations sur le nouvel utilisateur :

   dn: uid=stageidmuser,cn=staged users,cn=accounts,cn=provisioning,dc=idm,dc=example,dc=com
   changetype: add
   objectClass: top
   objectClass: inetorgperson
   uid: stageidmuser
   sn: surname
   givenName: first_name
   cn: full_name

2. Transférer le fichier LDIF du serveur externe vers le serveur IdM :

   $ scp add-stageidmuser.ldif provisionator@server.idm.example.com:/provisionator/
   Password:
   add-stageidmuser.ldif                                                                                          100%  364   217.6KB/s   00:00

3. Utilisez le protocole SSH pour vous connecter au serveur IdM en tant que provisionator:

   $ ssh provisionator@server.idm.example.com
   Password:
   [provisionator@server ~]$

4. Sur le serveur IdM, obtenez le ticket Kerberos (TGT) pour le compte du provisionneur :

   [provisionator@server ~]$ kinit provisionator

5. Saisir la commande ldapadd avec l'option -f et le nom du fichier LDIF. Spécifiez le nom du serveur IdM et le numéro de port :

   ~]$ ldapadd -h server.idm.example.com -p 389 -f  add-stageidmuser.ldif
   SASL/GSSAPI authentication started
   SASL username: provisionator@IDM.EXAMPLE.COM
   SASL SSF: 256
   SASL data security layer installed.
   adding the entry "uid=stageidmuser,cn=staged users,cn=accounts,cn=provisioning,dc=idm,dc=example,dc=com"

Procédure

1. Utilisez le protocole SSH pour vous connecter au serveur IdM en utilisant votre identité et vos informations d'identification IdM :

   $ ssh provisionator@server.idm.example.com
   Password:
   [provisionator@server ~]$

2. Obtenir le TGT du compte provisionator, un utilisateur IdM ayant le rôle d'ajouter de nouveaux utilisateurs de scène :

   $ kinit provisionator

3. Entrez dans la commande ldapmodify et spécifiez Generic Security Services API (GSSAPI) comme mécanisme SASL (Simple Authentication and Security Layer) à utiliser pour l'authentification. Indiquez le nom du serveur IdM et le port :

   # ldapmodify -h server.idm.example.com -p 389 -Y GSSAPI
   SASL/GSSAPI authentication started
   SASL username: provisionator@IDM.EXAMPLE.COM
   SASL SSF: 56
   SASL data security layer installed.

4. Saisissez l'adresse dn de l'utilisateur que vous ajoutez :

   dn : uid=stageuser,cn=staged users,cn=accounts,cn=provisioning,dc=idm,dc=example,dc=com

5. Saisissez add comme type de modification à effectuer :

   changetype : add

6. Spécifier les catégories de classes d'objets LDAP requises pour permettre le traitement correct du cycle de vie de l'utilisateur :

   objectClass: top
   objectClass: inetorgperson

   Vous pouvez spécifier des classes d'objets supplémentaires.

7. Saisissez l'adresse uid de l'utilisateur :

   uid : stageuser

8. Saisissez l'adresse cn de l'utilisateur :

   cn : Babs Jensen

9. Saisissez le nom de famille de l'utilisateur :

   sn : Jensen

10. Appuyez à nouveau sur Enter pour confirmer la fin de l'entrée :

    [Enter]
    
    adding new entry "uid=stageuser,cn=staged users,cn=accounts,cn=provisioning,dc=idm,dc=example,dc=com"

11. Quittez la connexion en utilisant Ctrl C .

1. Un client Kerberos s'identifie auprès du KDC en s'authentifiant en tant que principal Kerberos. Par exemple, un utilisateur IdM effectue kinit username et fournit son mot de passe.
2. Le KDC vérifie la présence du principal dans sa base de données, authentifie le client et évalue les politiques de tickets Kerberos afin de déterminer s'il convient d'accéder à la demande.
3. Le KDC délivre au client un ticket d'attribution de ticket (TGT) avec un cycle de vie et des indicateurs d'authentification conformément à la politique de ticket appropriée.
4. Avec le TGT, le client demande une adresse service ticket au KDC pour communiquer avec un service Kerberisé sur un hôte cible.
5. Le KDC vérifie si le TGT du client est toujours valide et évalue la demande de ticket de service par rapport aux politiques de ticket.
6. Le KDC délivre au client une adresse service ticket.
7. Avec le ticket de service, le client peut initier une communication cryptée avec le service sur l'hôte cible.

Procédure

1. Pour modifier la politique globale en matière de tickets :

   [root@server ~]# ipa krbtpolicy-mod --maxlife=$((8*60*60)) --maxrenew=$((24*60*60))
     Max life: 28800
     Max renew: 86400

   In this example, the maximum lifetime is set to eight hours (8 * 60 minutes * 60 seconds) and the maximum renewal age is set to one day (24 * 60 minutes * 60 seconds).

2. Facultatif : Pour rétablir les valeurs d'installation par défaut de la politique globale en matière de tickets Kerberos :

   [root@server ~]# ipa krbtpolicy-reset
     Max life: 86400
     Max renew: 604800

Procédure

1. Par exemple, pour définir la durée de vie maximale du ticket de l'utilisateur IdM admin à deux jours et l'âge maximal de renouvellement à deux semaines :

   [root@server ~]# ipa krbtpolicy-mod admin --maxlife=172800 --maxrenew=1209600
     Max life: 172800
     Max renew: 1209600

2. Optionnel : Pour réinitialiser la politique de ticket d'un utilisateur :

   [root@server ~]# ipa krbtpolicy-reset admin

Procédure

1. Par exemple, pour permettre à l'utilisateur d'IdM admin de renouveler un ticket Kerberos pendant deux jours s'il a été obtenu avec l'authentification par mot de passe à usage unique, définissez l'option --otp-maxrenew:

   [root@server ~]# ipa krbtpolicy-mod admin --otp-maxrenew=$((2*24*60*60))
     OTP max renew: 172800

2. Optionnel : Pour réinitialiser la politique de ticket d'un utilisateur :

   [root@server ~]# ipa krbtpolicy-reset username

Procédure

1. Affichez le KVNO des mandants dans le keytab que vous vérifiez. Dans l'exemple suivant, le fichier /etc/named.keytab contient la clé du principal DNS/server1.idm.example.com@EXAMPLE.COM avec un KVNO de 2.

   [root@server1 ~]# klist -ekt /etc/named.keytab
   Keytab name: FILE:/etc/named.keytab
   KVNO Timestamp           Principal
   ---- ------------------- ------------------------------------------------------
      2 11/26/2021 13:51:11 DNS/server1.idm.example.com@EXAMPLE.COM (aes256-cts-hmac-sha1-96)
      2 11/26/2021 13:51:11 DNS/server1.idm.example.com@EXAMPLE.COM (aes128-cts-hmac-sha1-96)
      2 11/26/2021 13:51:11 DNS/server1.idm.example.com@EXAMPLE.COM (camellia128-cts-cmac)
      2 11/26/2021 13:51:11 DNS/server1.idm.example.com@EXAMPLE.COM (camellia256-cts-cmac)

2. Afficher le KVNO du principal stocké dans la base de données IdM. Dans cet exemple, le KVNO de la clé dans la base de données IdM ne correspond pas au KVNO dans la base de données.

   [root@server1 ~]# kvno DNS/server1.idm.example.com@EXAMPLE.COM
   DNS/server1.idm.example.com@EXAMPLE.COM: kvno = 3

3. S'authentifier en tant que compte administrateur IdM.

   [root@server1 ~]# kinit admin
   Password for admin@IDM.EXAMPLE.COM:

4. Récupérez une clé Kerberos mise à jour pour le principal et stockez-la dans son keytab. Effectuez cette étape en tant qu'utilisateur root afin de pouvoir modifier le fichier /etc/named.keytab, qui appartient à l'utilisateur named.

   [root@server1 ~]# ipa-getkeytab -s server1.idm.example.com -p DNS/server1.idm.example.com -k /etc/named.keytab

Vérification

1. Affiche le KVNO mis à jour du principal dans la base de données des clés.

   [root@server1 ~]# klist -ekt /etc/named.keytab
   Keytab name: FILE:/etc/named.keytab
   KVNO Timestamp           Principal
   ---- ------------------- ------------------------------------------------------
      4 08/17/2022 14:42:11 DNS/server1.idm.example.com@EXAMPLE.COM (aes256-cts-hmac-sha1-96)
      4 08/17/2022 14:42:11 DNS/server1.idm.example.com@EXAMPLE.COM (aes128-cts-hmac-sha1-96)
      4 08/17/2022 14:42:11 DNS/server1.idm.example.com@EXAMPLE.COM (camellia128-cts-cmac)
      4 08/17/2022 14:42:11 DNS/server1.idm.example.com@EXAMPLE.COM (camellia256-cts-cmac)

2. Afficher le KVNO du principal stocké dans la base de données IdM et s'assurer qu'il correspond au KVNO de la base de données.

   [root@server1 ~]# kvno DNS/server1.idm.example.com@EXAMPLE.COM
   DNS/server1.idm.example.com@EXAMPLE.COM: kvno = 4

Procédure

1. Ouvrez le fichier /etc/krb5.conf pour le modifier.

2. Dans la section [realms], entrez l'URL du KKDCP pour les options kdc, admin_server et kpasswd_server:

   [realms]
   EXAMPLE.COM = {
     kdc = https://kdc.example.com/KdcProxy
     admin_server = https://kdc.example.com/KdcProxy
     kpasswd_server = https://kdc.example.com/KdcProxy
     default_domain = example.com
   }

   Pour des raisons de redondance, vous pouvez ajouter les paramètres kdc, admin_server, et kpasswd_server plusieurs fois pour indiquer différents serveurs KKDCP.

3. Redémarrez le service sssd pour que les modifications soient prises en compte :

   ~]# systemctl restart sssd

Procédure

1. Supprimer la paire d'attributs et de valeurs ipaConfigString=kdcProxyEnabled du répertoire :

   # ipa-ldap-updater /usr/share/ipa/kdcproxy-disable.uldif
   Update complete
   The ipa-ldap-updater command was successful

2. Redémarrez le service httpd:

   # systemctl restart httpd.service

Procédure

1. Ajoutez la paire d'attributs et de valeurs ipaConfigString=kdcProxyEnabled au répertoire :

   # ipa-ldap-updater /usr/share/ipa/kdcproxy-enable.uldif
   Update complete
   The ipa-ldap-updater command was successful

2. Redémarrez le service httpd:

   # systemctl restart httpd.service

Procédure

1. Dans la section [global] du fichier /etc/ipa/kdcproxy/kdcproxy.conf, le paramètre use_dns doit être réglé sur false.

   [global]
   use_dns = false

2. Placez les informations relatives à la zone mandataire dans le fichier /etc/ipa/kdcproxy/kdcproxy.conf. Par exemple, pour la zone [AD.EXAMPLE.COM] avec proxy, listez les paramètres de configuration de la zone comme suit :

   [AD.EXAMPLE.COM]
   kerberos = kerberos+tcp://1.2.3.4:88 kerberos+tcp://5.6.7.8:88
   kpasswd = kpasswd+tcp://1.2.3.4:464 kpasswd+tcp://5.6.7.8:464

   Important

   Les paramètres de configuration du domaine doivent énumérer plusieurs serveurs séparés par un espace, contrairement à /etc/krb5.conf et kdc.conf, dans lesquels certaines options peuvent être spécifiées plusieurs fois.

3. Redémarrer les services de gestion des identités (IdM) :

   # ipactl restart

Procédure

1. Dans le fichier /etc/ipa/kdcproxy/kdcproxy.conf, à la section [global], le paramètre use_dns est remplacé par true.

   [global]
   configs = mit
   use_dns = true

   Le paramètre configs permet de charger d'autres modules de configuration. Dans ce cas, la configuration est lue à partir de la bibliothèque MIT libkrb5.

2. Optional: Si vous ne souhaitez pas utiliser les enregistrements de service DNS, ajoutez des serveurs AD explicites à la section [realms] du fichier /etc/krb5.conf. Si le domaine avec proxy est, par exemple, AD.EXAMPLE.COM, vous ajoutez :

   [realms]
   AD.EXAMPLE.COM = {
       kdc = ad-server.ad.example.com
       kpasswd_server = ad-server.ad.example.com
   }

3. Redémarrer les services de gestion des identités (IdM) :

   # ipactl restart

Procédure

1. Optional: Affichez les règles de libre-service existantes à l'aide de la commande ipa selfservice-find.
2. Optional: Affiche les détails de la règle de libre-service que vous souhaitez modifier à l'aide de la commande ipa selfservice-show.
3. Utilisez la commande ipa selfservice-mod pour modifier une règle de libre-service.

Procédure

1. Ouvrez le sous-menu Role-Based Access Control dans l'onglet IPA Server et sélectionnez Self Service Permissions.

2. Cliquez sur Add en haut à droite de la liste des règles d'accès en libre-service :

   

3. La fenêtre Add Self Service Permission s'ouvre. Saisissez le nom de la nouvelle règle de libre-service dans le champ Self-service name. Les espaces sont autorisés :

   

4. Cochez les cases en regard des attributs que vous souhaitez que les utilisateurs puissent modifier.

5. Optional: Si un attribut auquel vous souhaitez donner accès n'est pas répertorié, vous pouvez en ajouter un :

   1. Cliquez sur le bouton Add.
   2. Saisissez le nom de l'attribut dans le champ de texte Attribute de la fenêtre suivante Add Custom Attribute.
   3. Cliquez sur le bouton OK pour ajouter l'attribut
   4. Vérifier que le nouvel attribut est sélectionné
6. Cliquez sur le bouton Add au bas du formulaire pour enregistrer la nouvelle règle de libre-service.
   Vous pouvez également enregistrer et continuer à modifier la règle de libre-service en cliquant sur le bouton Add and Edit, ou enregistrer et ajouter d'autres règles en cliquant sur le bouton Add and Add another.

Procédure

1. Ouvrez le sous-menu Role-Based Access Control dans l'onglet IPA Server et sélectionnez Self Service Permissions.

2. Cliquez sur le nom de la règle de libre-service que vous souhaitez modifier.

   

3. La page d'édition vous permet uniquement de modifier la liste des attributs que vous souhaitez ajouter ou supprimer de la règle de libre-service. Cochez ou décochez les cases appropriées.
4. Cliquez sur le bouton Save pour enregistrer les modifications apportées à la règle de libre-service.

Procédure

1. Ouvrez le sous-menu Role-Based Access Control dans l'onglet IPA Server et sélectionnez Self Service Permissions.

2. Cochez la case en regard de la règle que vous souhaitez supprimer, puis cliquez sur le bouton Delete à droite de la liste.

   

3. Une boîte de dialogue s'ouvre, cliquez sur Delete pour confirmer.

Procédure

1. Naviguez jusqu'au répertoire ~/MyPlaybooks/ répertoire :

   $ cd ~/MyPlaybooks/

2. Faites une copie du fichier selfservice-present.yml situé dans le répertoire /usr/share/doc/ansible-freeipa/playbooks/selfservice/:

   $ cp /usr/share/doc/ansible-freeipa/playbooks/selfservice/selfservice-present.yml selfservice-present-copy.yml

3. Ouvrez le fichier selfservice-present-copy.yml Ansible playbook pour l'éditer.

4. Adaptez le fichier en définissant les variables suivantes dans la section ipaselfservice task :

   • Définissez la variable ipaadmin_password avec le mot de passe de l'administrateur IdM.
   • Définissez la variable name avec le nom de la nouvelle règle de libre-service.
   • Attribuez à la variable permission une liste de permissions à accorder, séparées par des virgules : read et write.
   • Définissez la variable attribute avec une liste d'attributs que les utilisateurs peuvent gérer eux-mêmes : givenname, displayname, title, et initials.

   Il s'agit du fichier playbook Ansible modifié pour l'exemple actuel :

   ---
   - name: Self-service present
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Ensure self-service rule "Users can manage their own name details" is present
       ipaselfservice:
         ipaadmin_password: "{{ ipaadmin_password }}"
         name: "Users can manage their own name details"
         permission: read, write
         attribute:
         - givenname
         - displayname
         - title
         - initials

5. Enregistrer le fichier.

6. 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 selfservice-present-copy.yml

Procédure

1. Naviguez jusqu'au répertoire ~/MyPlaybooks/ répertoire :

   $ cd ~/MyPlaybooks/

2. Faites une copie du fichier selfservice-absent.yml situé dans le répertoire /usr/share/doc/ansible-freeipa/playbooks/selfservice/:

   $ cp /usr/share/doc/ansible-freeipa/playbooks/selfservice/selfservice-absent.yml selfservice-absent-copy.yml

3. Ouvrez le fichier selfservice-absent-copy.yml Ansible playbook pour l'éditer.

4. Adaptez le fichier en définissant les variables suivantes dans la section ipaselfservice task :

   • Définissez la variable ipaadmin_password avec le mot de passe de l'administrateur IdM.
   • Définissez la variable name avec le nom de la règle de libre-service.
   • Fixer la variable state à absent.

   Il s'agit du fichier playbook Ansible modifié pour l'exemple actuel :

   ---
   - name: Self-service absent
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Ensure self-service rule "Users can manage their own name details" is absent
       ipaselfservice:
         ipaadmin_password: "{{ ipaadmin_password }}"
         name: "Users can manage their own name details"
         state: absent

5. Enregistrer le fichier.

6. 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 selfservice-absent-copy.yml

Procédure

1. Naviguez jusqu'au répertoire ~/MyPlaybooks/ répertoire :

   $ cd ~/MyPlaybooks/

2. Faites une copie du fichier selfservice-member-present.yml situé dans le répertoire /usr/share/doc/ansible-freeipa/playbooks/selfservice/:

   $ cp /usr/share/doc/ansible-freeipa/playbooks/selfservice/selfservice-member-present.yml selfservice-member-present-copy.yml

3. Ouvrez le fichier selfservice-member-present-copy.yml Ansible playbook pour l'éditer.

4. Adaptez le fichier en définissant les variables suivantes dans la section ipaselfservice task :

   • Définissez la variable ipaadmin_password avec le mot de passe de l'administrateur IdM.
   • Définissez la variable name avec le nom de la règle de libre-service à modifier.
   • Fixer la variable attribute à surname.
   • Fixer la variable action à member.

   Il s'agit du fichier playbook Ansible modifié pour l'exemple actuel :

   ---
   - name: Self-service member present
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Ensure selfservice "Users can manage their own name details" member attribute surname is present
       ipaselfservice:
         ipaadmin_password: "{{ ipaadmin_password }}"
         name: "Users can manage their own name details"
         attribute:
         - surname
         action: member

5. Enregistrer le fichier.

6. 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 selfservice-member-present-copy.yml

Procédure

1. Naviguez jusqu'au répertoire ~/MyPlaybooks/ répertoire :

   $ cd ~/MyPlaybooks/

2. Faites une copie du fichier selfservice-member-absent.yml situé dans le répertoire /usr/share/doc/ansible-freeipa/playbooks/selfservice/:

   $ cp /usr/share/doc/ansible-freeipa/playbooks/selfservice/selfservice-member-absent.yml selfservice-member-absent-copy.yml

3. Ouvrez le fichier selfservice-member-absent-copy.yml Ansible playbook pour l'éditer.

4. Adaptez le fichier en définissant les variables suivantes dans la section ipaselfservice task :

   • Définissez la variable ipaadmin_password avec le mot de passe de l'administrateur IdM.
   • Définissez la variable name avec le nom de la règle de libre-service que vous souhaitez modifier.
   • Fixez la variable attribute à givenname et surname.
   • Fixer la variable action à member.
   • Fixer la variable state à absent.

   Il s'agit du fichier playbook Ansible modifié pour l'exemple actuel :

   ---
   - name: Self-service member absent
     hosts: ipaserver
   
     vars_files:
     - /home/user_name/MyPlaybooks/secret.yml
     tasks:
     - name: Ensure selfservice "Users can manage their own name details" member attributes givenname and surname are absent
       ipaselfservice:
         ipaadmin_password: "{{ ipaadmin_password }}"
         name: "Users can manage their own name details"
         attribute:
         - givenname
         - surname
         action: member
         state: absent

5. Enregistrer le fichier.

6. 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 selfservice-member-absent-copy.yml

Procédure

1. Optional. Utilisez la commande ipa group-show pour confirmer que le groupe inclut le membre que vous souhaitez supprimer.

2. Supprimer un membre d'un groupe d'utilisateurs à l'aide de la commande ipa group-remove-member.

   Spécifiez les membres à supprimer à l'aide de ces options :

   • --users supprime un utilisateur IdM
   • --external supprime un utilisateur qui existe en dehors du domaine IdM, sous le format DOMAIN\user_name ou user_name@domain
   • --groups supprime un groupe d'utilisateurs IdM

   Par exemple, pour supprimer user1, user2 et group1 d'un groupe appelé group_name:

   $ ipa group-remove-member group_name --users=user1 --users=user2 --groups=group1