Cela fait un moment que je discute avec Centrify de l’intérêt de fournir des Cmdlets PowerShell, parce qu’à chaque fois que la gestion des données stockées de l’AD sera effectuée par des équipes Windows, l’utilisation de PowerShell est aujourd’hui plus séduisante que des scripts VB !

Voici donc ma contribution aux outils fournis par Centrify, leur succès sur site fait que les Cmdlets PowerShell seront intégrés prochainement dans la Suite Centrify (probablement à partir de la 5.1).

Je posterai plusieurs exemples de scripts aidant à la gestion de Centrify ou aidant la migration des données depuis Unix vers AD, mais en attendant…

Bon scripting ^^

Visiter la page dédiée : Centrify PowerShell Module

Oui mais voilà, généralement on créé des structures relativement identiques, et si on pouvais disposer d’un script suffisamment générique pour créer tout ça ?

Eh bien oui c’est possible, voilà donc un script PowerShell à base de PS 2.0, qui reçoit en entrée un fichier texte décrivant les opérations à faire dans l’annuaire AD de son choix. Ce script m’a été inspiré par un script VBS que j’ai eu l’occasion d’utiliser il y a bientôt deux ans dans un grand groupe international, merci à l’auteur de ce premier script dont j’ai malheureusement complétement oublié le nom Oo.

J’ai créé une page dédiée à ce script, n’hésitez pas à l’utiliser et à me faire part de vos remarques ^^

La page du script ADInit : ADInit

La page de téléchargement : ADInit Download

Les éditeurs du jeu en ligne Star Wars – The Old Republic proposent d’utiliser un token OTP pour sécuriser l’accés à votre compte en ligne lorsque vous jouer. En effet le principe de l’OTP fait que le code généré par le token que vous possédez est vérifiable, c’est à dire que le token associé à votre compte ne peut générer qu’une certaine série de code (et dans un ordre vérifiable), garantissant ainsi un deuxiéme facteur d’authentification :

• Ce que je sais : le mot de passe de mon compte
• Ce que je possède : le token OTP générant un code vérifiable

A quand l’authentification par certificat numérique ou par biométrie pour ajouter un troisième facteur  ? (Ce que je suis)

La page d’info sur l’utilisation de votre token OTP : http://www.swtor.com/fr/clesecurisee

Microsoft propose un Widget pour Visual Studio permettant de débloquer des badges au fur et à mesure d’accomplissements, histoire de prendre Visual Studio pour un jeu Steam

Les badges sont rangés dans plusieurs catégories, un pop-up s’affiche dans Visual studio à chaque fois que vous gagnez un nouveau badge et vous allez même povoir twitter, facebooker, googler, bref pourrir le mur de vos potes, à chaque fois que vous aurez un badge.

Pour en savoir plus, lire le post du Blog Officiel de Visual Studio : http://blogs.msdn.com/b/visualstudio/archive/2012/01/18/announcing-visual-studio-achievements.aspx

Bonne lecture à tous.

Le livre blanc en téléchargement  ici : Solutions de Cloud Privé Microsoft

Bon, une case à cocher c’est très bien, mais quand on viens de faire un joli script qui nous créé en une seule passe les 150 OU de notre organisation AD, quand viens le moment de cocher 150 cases il viens comme une envie de se pendre (surtout qu’avant d’atteindre la case à cocher il aura fallu malmener sérieusement le clic gauche de la souris -_-)

En réalité, derrière cette case à cocher se cache trois ACE très simples, l’octroi du refus pour le groupe Builtin « Tout le monde » sur l’objet en question:

• Delete
• DeleteChild
• DeleteTree

Maintenant il ne me reste plus qu’à vous montrer comment appliquer des ACE sur un objet de l’AD avec un script PowerShell.

Je ne vais décrire ici que la partie qui nous intéresse, se connecter à un objet ActiveDirectory de type OU pour l’exemple (ca marche évidement avec n’importe quel objet).

Le principe est assez simple, on commence par se connecter à l’objet avec la classe DirectoryServices.DirectoryEntry, puis on crée des objets ACE avec la classe DirectoryServices.ActiveDirectoryAccessRule.

Cette classe attend plusieurs paramètre dont le SID de l’objet qui va bénéficier de l’ACE, dans notre cas le SID est S-1-1-0 (SID spécifique correspondant au groupe Builtin « Tout le monde »).

Il faut également spécifier les droits que l’on veux authoriser ou refuser avec la collection DirectoryServices.ActiveDirectoryRights.

Finalement on précise le type d’ACE (Allow ou Deny) et l’héritage (ici None ce qui correspond à l’objet lui-même), respectivement avec les collections System.AccessControl.AccessControlType et DirectoryServices.ActiveDirectorySecurityInheritance.

Ne reste plus qu’à ajouter les ACE à l’objet et à valider le tout avec un Commit.

# Connect to Object
$Object = New-Object System.DirectoryServices.DirectoryEntry("LDAP://OU=Test,DC=olympe,DC=demo")
# Add ACE to Deny Delete, DeleteChild and DeleteTree for Everyone (which is actually the rights to protected from accidental deletion)
$Trustee = New-Object Security.Principal.SecurityIdentifier("S-1-1-0") # S-1-1-0 is the SID for Everyone Built-In Group
$ACType = [Security.AccessControl.AccessControlType]::Deny
$Inheritance = [DirectoryServices.ActiveDirectorySecurityInheritance]::None
# Create and add ACE
$ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule($Trustee, [DirectoryServices.ActiveDirectoryRights]::Delete, $ACType, $Inheritance)
$Object.psbase.ObjectSecurity.AddAccessRule($ACE)
$ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule($Trustee, [DirectoryServices.ActiveDirectoryRights]::DeleteChild, $ACType, $Inheritance)
$Object.psbase.ObjectSecurity.AddAccessRule($ACE)
$ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule($Trustee, [DirectoryServices.ActiveDirectoryRights]::DeleteTree, $ACType, $Inheritance)
$Object.psbase.ObjectSecurity.AddAccessRule($ACE)
# Apply ACE
$Object.psbase.CommitChanges()

Si la case à cocher est disponible dans le clicodrome uniquement, en utilisant un script adapté on peut imaginer protéger n’importe quel objet que l’on crée ou veux modifier. Par exemple des groupes de sécurité utilisés pour la délégation, ou bien des listes de distribution, ou encore des comptes de services.

Bref, cela permet d’éviter bien des sueurs à nos admins de domaine ^^

L’utilisation de Kerberos ou de certificats peut palier l’utilisation de mot de passes et donc rendre l’authentification bien plus sécurisée. Une autre alternative et l’utilisation de clefs RSA pour l’authentification SSH. L’authentification RSA pour les connexions SSH se basent sur un échange de clefs et la signature de jetons d’authentification au moment de la connexion.

Authentification RSA

Le principe de l’authentification RSA se base sur la signature de jetons d’authentification lors de la connexion. Le client dispose d’une paire de clefs d’authentification : une clef privée qu’il est le seul à détenir et une clef publique que les serveurs utiliseront pour vérifier l’identité du client. Au moment de l’authentification, le client signe un jeton avec sa clef privée et le donne au serveur sur lequel il a besoin de s’authentifier. Le serveur doit avoir accès à la clef publique du client pour décrypter le jeton d’authentification. Comme lors de l’utilisation d’un algorithme de cryptage, seule la clef publique correspondant à la clef privée permet de décrypter le message : c’est le principe de signature numérique. Le serveur, avec la clef publique, peut donc vérifier la signature du jeton d’authentification, en ayant l’assurance que seul le client a pu générer la signature (le client est le seul à détenir la clef privée).

Génération d’une paire de clefs sur Linux

Sur la machine cliente on peut générer une paire de clefs RSA avec la commande suivante :

badrogh@demeter:~$ ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/badrogh/.ssh/id_rsa):
Created directory '/home/badrogh/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/badrogh/.ssh/id_rsa.
Your public key has been saved in /home/badrogh/.ssh/id_rsa.pub.
The key fingerprint is:
44:1b:94:be:04:4a:34:ca:ad:af:16:43:a2:28:b4:8c badrogh@demeter
The key's randomart image is:
+--[ RSA 2048]----+
|   .o  .+.       |
| . o.....o       |
|  o... oo        |
|.....  .o        |
|*oo    .S.       |
|Eoo.    .        |
|.  o.            |
|  ..             |
| ..              |
+-----------------+
badrogh@demeter:~$

Par défaut la clef privée est sauvegardée dans le fichier id_rsa dans un répertoire caché nommé .ssh de la homedir de l’utilisateur. La clef publique correspondante est sauvegardée dans le fichier id_rsa.pub dans le même répertoire. Lorsque l’on génère la clef privée, il est possible de protéger l’accès à cette clef par une phrase (appelée passphrase). Cela renforce la sécurité mais oblige à saisir cette phrase à chaque fois que l’on utilise la clef privée, ce qui perd tout intérêt quand l’authentification se fait dans un script.

Ajout de la clef publique sur le serveur

Pour permettre l’authentification par clef RSA sur le serveur, il est nécessaire d’ajouter la clef publique de l’utilisateur dans le fichier de clefs autorisées sur le serveur. Pour cela il faut connaitre le mot de passe de l’utilisateur sur le serveur et utiliser la commande suivante :

badrogh@demeter:~$ ssh-copy-id -i /home/badrogh/.ssh/id_rsa.pub badrogh@athena
Red Hat Enterprise Linux Server release 5.5 (Tikanga)
Kernel 2.6.18-194.el5 on an x86_64

Password:
Now try logging into the machine, with "ssh 'badrogh@athena'", and check in:

 .ssh/authorized_keys

to make sure we haven't added extra keys that you weren't expecting.

badrogh@demeter:~$

Le service SSH doit également être configuré pour accepter l’authentification par clefs RSA. Le fichier de configuration du serveur SSH doit contenir les paramètres suivants :

RSAAuthentication yes
PubkeyAuthentication yes
AuthorizedKeysFile      .ssh/authorized_keys

Si vous avez besoin d’ajouter ces lignes de configuration ou de les dé-commenter, n’oubliez pas de redémarrer le service sshd !

A partir de là on peut s’authentifier sans mot de passe depuis les machines qui utilise la clef privée de l’utilisateur pour se connecter en SSH :

badrogh@demeter:~$ ssh athena
Red Hat Enterprise Linux Server release 5.5 (Tikanga)
Kernel 2.6.18-194.el5 on an x86_64

Last login: Mon Jan  2 11:41:33 2012 from demeter.olympe.demo
[badrogh@athena ~]$

Utilisation de clefs RSA avec PuTTy

Maintenant que nous avons généré une paire de clefs pour notre utilisateur et configuré le serveur, on peut utiliser cette méthode d’authentification même depuis une machine Windows avec le client SSH libre PuTTy.

Pour commencer il nous faut copier la clef privée générée pour notre utilisateur sur la machine Windows depuis laquelle on veux se connecter :

Ensuite nous allons convertir cette clef dans un format utilisable par PuTTy avec l’outil puttygen.exe, disponible dans le répertoire d’installation. Notons que cet outil aurait pu être également utilisé pour générer une paire de clefs RSA, dans ce cas nous aurions dû sauvegarder la clef publique générée et ajouter cette clef dans le fichier autorized_keys du serveur. Ici nous allons convertir notre clef existante :

On peut nommer la clef ainsi convertie et la sauvegarder au format ppk utilisé par PuTTy :

Une fois la clef sauvegardée (bouton Save private key), on a maintenant une clef utilisable pour nos sessions SSH :

Configuration de la connexion SSH dans PuTTy

Commençons par ouvrir PuTTy puis précisons le nom de login à utiliser pour la connexion SSH dans l’onglet Connection > Data :

Puis ajoutons la clef privée à utiliser pour la connexion SSH dans l’onglet Connection > SSH > Auth (bouton Browse de la section Authentication parameters) :

Il nous reste à spécifier le nom du serveur où l’on veux se connecter (et où on a préalablement ajouter la clef publique dans le fichier de clefs autorisées), on peut même se sauvegarder la connexion pour la prochaine fois :

A partir de là on peut se connecter en SSH avec PuTTy sans mot de passe :

Et voilà

Voici la suite de mon article sur la création d’une Custom Activity pour FIM 2010.

Cette activité a été créé dans la FIMCustomActivityLibrary préparée dans la première partie de ce guide : FIM Custom Activity – Guide de création (partie 1)

Un deuxième article montre comment ajouter des activités et écrire le code source de ces activités : FIM Custom Activity – Guide de création (partie 2)

Dans cette troisième partie, je vais décrire comment créer l’interface homme machine (plus communément appelé GUI) de cette activité. Cette interface est un formulaire qui sera affiché dans le portail FIM et nous permettra d’ajouter des activités dans l’éditeur de Worklfow de FIM 2010.

Création de la classe SettingsPart

Pour commencer nous allons ajouter à notre projet Visual Studio une nouvelle classe nommée RequestLoggingActivitySettingsPart.cs

Le code source généré est le suivant :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace FIMCustomActivityLibrary.RequestLoggingActivity
{
     class RequestLoggingActivitySettingsPart
     {
     }
}

Nous allons y ajouter les informations de références nécessaires, changer l’espace de nom pour accéder aux classes de l’interface utilisateur du portail FIM (classe WebUI) et également hériter la classe que l’on vient de créer de la classe ActivitySettingsPart :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
// Added references
using System.Web.UI.WebControls;
using System.Workflow.ComponentModel;
using Microsoft.IdentityManagement.WebUI.Controls;
using Microsoft.ResourceManagement.Workflow.Activities;
using FIMCustomActivityLibrary.RequestLoggingActivity.RequestLoggingActivity;

namespace FIMCustomActivityLibrary.RequestLoggingActivity.WebUI
{
     class RequestLoggingActivitySettingsPart : ActivitySettingsPart
     {
     }
}

Maintenant nous pouvons instancier les méthodes de la classe WebUI en effectuant un clic droit sur le mot clef ActivitySettingsPart et en choisissant Implémenter une classe abstraite

Méthodes utiles

Afin de générer des éléments dans l’interface WebUI, nous allons devoir écrire quelques méthodes permettant de dessiner un tableau, écrire du texte, lire du texte, etc. A chaque fois que nous aurons à écrire une nouvelle activité personnalisée, nous aurons besoin de ces méthodes. Dans cet exemple seule des méthodes permettant de dessiner des champs de texte simpe sont utilisées, mais on peut imaginer ici dessiner n’importe quel champs de saisie classique de type radio bouton, liste déroulante, etc.

Ajoutons donc une région à notre classe avec les méthodes utiles:

#region Utility Functions
// Create a TableRow that contains a label and a textbox.
private TableRow AddTableRowTextBox(String labelText, String controlID, Int32 width, Int32 maxLength, Boolean multiLine, String defaultValue)
{
     TableRow row = new TableRow();
     TableCell labelCell = new TableCell();
     TableCell controlCell = new TableCell();
     Label oLabel = new Label();
     TextBox oText = new TextBox();

     oLabel.Text = labelText;
     oLabel.CssClass = base.LabelCssClass;
     labelCell.Controls.Add(oLabel);
     oText.ID = controlID;
     oText.CssClass = base.TextBoxCssClass;
     oText.Text = defaultValue;
     oText.MaxLength = maxLength;
     oText.Width = width;
     if (multiLine)
     {
          oText.TextMode = TextBoxMode.MultiLine;
          oText.Rows = System.Math.Min(6, (maxLength + 60) / 60);
          oText.Wrap = true;
     }
     controlCell.Controls.Add(oText);
     row.Cells.Add(labelCell);
     row.Cells.Add(controlCell);
     return row;
}

string GetText(String textBoxID)
{
     TextBox textBox = (TextBox)this.FindControl(textBoxID);
     return textBox.Text ?? String.Empty;
}

void SetText(String textBoxID, String text)
{
     TextBox textBox = (TextBox)this.FindControl(textBoxID);
     if (textBox != null)
          textBox.Text = text;
     else
          textBox.Text = "";
}

// Set the text box to read mode or read/write mode
void SetTextBoxReadOnlyOption(String textBoxID, Boolean readOnly)
{
     TextBox textBox = (TextBox)this.FindControl(textBoxID);
     textBox.ReadOnly = readOnly;
}
#endregion

Méthode CreateChildControls

La méthode CreateChildControls va nous permettre de dessiner un tableau contenant les différents contrôle de formulaire de la WebUI de notre activité. On ajoute cette méthode à la liste des méthodes instanciées précédemment :

/// <summary>
///  Creates a Table that contains the controls used by the activity UI
///  in the Workflow Designer of the FIM portal. Adds that Table to the
///  collection of Controls that defines each activity that can be selected
///  in the Workflow Designer of the FIM Portal. Calls the base class of
///  ActivitySettingsPart to render the controls in the UI.
/// </summary>
protected override void CreateChildControls()
{
     Table controlLayoutTable = new Table();

     // Width is set to 100% of the control size
     controlLayoutTable.Width = Unit.Percentage(100.0);
     controlLayoutTable.BorderWidth = 0;
     controlLayoutTable.CellPadding = 2;
     // Add a TableRow for each textbox in the UI
     controlLayoutTable.Rows.Add(this.AddTableRowTextBox("Logging Activity Name:", "txtLoggingActivityName", 400, 100, false, "Enter the logging activity name (description title)."));
     controlLayoutTable.Rows.Add(this.AddTableRowTextBox("Log File Path:", "txtLogFilePath", 400, 100, false, "Enter the log file Path."));
     this.Controls.Add(controlLayoutTable);

     base.CreateChildControls();
}

Méthode GenerateActivityOnWorkflow

Cette méthode instancie l’objet de type RequestLoggingActivity et y associe les propriétés présentes dans les contrôles de la WebUI (c’est le constructeur de notre activité) :

/// <summary>
/// Called when a user clicks the Save button in the Workflow Designer.
/// Returns an instance of the RequestLoggingActivity class that
/// has its properties set to the values entered into the text box controls
/// used in the UI of the activity.
/// </summary>
public override Activity GenerateActivityOnWorkflow(SequentialWorkflow workflow)
{
     if (!this.ValidateInputs())
     {
          return null;
     }
     RequestLoggingActivity LoggingActivity = new RequestLoggingActivity();
     LoggingActivity.LoggingActivityName = this.GetText("txtLoggingActivityName");
     LoggingActivity.LogFilePath = this.GetText("txtLogFilePath");
     return LoggingActivity;
}

Méthode LoadActivitySettings

Cette méthode est appelée par FIM à chaque fois que l’activité est rechargée. Elle permet de lire les propriétés de l’activité actuellement instanciée par le Workflow :

/// <summary>
/// Called by FIM when the UI for the activity must be reloaded.
/// It passes us an instance of our workflow activity so that we can
/// extract the values of the properties to display in the UI.
/// </summary>
public override void LoadActivitySettings(Activity activity)
{
     RequestLoggingActivity LoggingActivity = activity as RequestLoggingActivity;
     if (null != LoggingActivity)
     {
          this.SetText("txtLoggingActivityName", LoggingActivity.LoggingActivityName);
          this.SetText("txtLogFilePath", LoggingActivity.LogFilePath);
     }
}

Méthode PersistSettings

Cette méthode permet d’enregistrer les valeurs saisies dans les contrôles vers les propriétés de l’activité. Cette méthode est appelée lors de l’appuie du bouton de validation d’une activité dans l’interface WebUI de FIM.

/// <summary>
/// Saves the activity settings.
/// </summary>
public override ActivitySettingsPartData PersistSettings()
{
     ActivitySettingsPartData data = new ActivitySettingsPartData();
     data["LoggingActivityName"] = this.GetText("txtLoggingActivityName");
     data["LogFilePath"] = this.GetText("txtLogFilePath");
     return data;
}

Méthode RestoreSettings

Cette méthode permet de lire les propriétés de l’activité et de les afficher dans la WebUI de FIM. C’est cette méthode qui est appelée lorsque l’on édite une activité existante.

/// <summary>
///  Restores the activity settings in the UI
/// </summary>
public override void RestoreSettings(ActivitySettingsPartData data)
{
     if (null != data)
     {
          this.SetText("txtLoggingActivityName", (String)data["LoggingActivityName"]);
          this.SetText("txtLogFilePath", (String)data["LogFilePath"]);
     }
}

Méthode SwitchMode

Cette méthode permet de passer les contrôles de la WebUI de lecture seule à lecture/écriture. Lorsque l’on affiche une activité existante, cette méthode est appelé quand le bouton Edit est pressé.

/// <summary>
///  Switches the activity between read only and read/write mode
/// </summary>
public override void SwitchMode(ActivitySettingsPartMode mode)
{
     Boolean readOnly = (mode == ActivitySettingsPartMode.View);
     this.SetTextBoxReadOnlyOption("txtLoggingActivityName", readOnly);
     this.SetTextBoxReadOnlyOption("txtLogFilePath", readOnly);
}

Méthode Title

Cette méthode permet d’afficher le titre (ou description) de l’activité. Très utile lorsque l’on créé des activités génériques manipulant des attributs différents. Par exemple si l’on créé plusieurs activités de log de requête : une à chaque création d’utilisateur, une autre à la suppression d’un utilisateur et enfin une à chaque modification de groupe, permettre de nommer différemment ces activités lorsqu’on les créé dans le portail devient indispensable !

/// <summary>
///  Returns the activity name.
/// </summary>
public override String Title
{
     get
     {
          if (String.IsNullOrEmpty(this.GetText("txtLoggingActivityName")))
               return "Request Logging Activity";
          else
               return "Request Logging Activity: " + this.GetText("txtLoggingActivityName");
     }
}

Méthode ValidateInputs

Cette méthode permet de vérifier la validité des valeurs saisies au moment de l’enregistrement de l’activité. Cette méthode doit retourner Vrai si les valeurs sont valides et Faux dans le cas contraire.

/// <summary>
///  This method should be used to validate information entered
///  by the user when the activity is added to a workflow in the Workflow
///  Designer.
///  We could add code to verify that the log file path already exists on
///  the server that is hosting the FIM Portal and check that the activity
///  has permission to write to that location. However, the code
///  would only check if the log file path exists when the
///  activity is added to a workflow in the workflow designer.
///  If you don't want to implement this class, just return true.
/// </summary>
public override Boolean ValidateInputs()
{
     Boolean InputsValid = false;
     // Test Log file path
     String Path = this.GetText("txtLogFilePath");
     if (System.IO.Directory.Exists(Path))
     {
          InputsValid = true;
     }
     return InputsValid;
}

Compilation et ajout dans le portail FIM

Notre librairie est maintenant prête à être compilée. Il ne nous restera plus qu’à ajouter cette librairie d’activités au portail FIM.

Je décrirai cette étape dans un quatrième article consacré aux Custom Activities FIM 2010.

Par exemple en suivant un ensemble de bonnes pratiques (et également avec une bonne dose de rigueur ^^).

Si vous aussi vous cherchez à instaurer des bonnes pratiques pour la mise en place de vos GPO, et quelques soit vos besoins, voici un livre blanc fourni par un ami décrivant les bonnes pratiques en place chez MS pour leur gestion des GPO.

Télécharger le pdf ici : GPO_Best Practices_How MSdoit

Si vous vous intéressez de près ou de loin à la fédération d’identité avec ADFS, sachez que la version 2.0 du guide “A Guide to Claims-Based Identity and Access Control” écrit par l’équipe Microsoft Patterns and Practices est disponible en téléchargement sur le site de MS:

A Guide to Claims-Based Identity and Access Control

Merci à Henrik Nilsson pour l’info