Utilisation des SecureString en Powershell

MARS14

La gestion de vos mots de passe en powershell se fait souvent via des securestring, si toutefois la gestion de vos mots de passe se passe via un ensemble de post-it proche de votre bureau, il s’agit d’un problème de sécurité, mais ce n’est pas le sujet ici.


Pour convertir vos mots de passe en securestring, vous pouvez exécuter le code suivant :

$original = 'myPassword'

$secureString = ConvertTo-SecureString $original -AsPlainText -Force


Cela vous donnera un objet de type System.Security.SecureString qui n’est pas très lisible comme cela, il est possible de récupérer une chaine de caractère correspondante à votre SecureString, mais cependant il ne s’agira pas de la chaine d’origine, comme on peut le voir ci-dessous :

$secureStringValue = ConvertFrom-SecureString $secureString

La valeur de notre variables secureStringValue est donc la suivante :

01000000d08c9ddf0115d1118c7a00c04fc297eb01000000e5e21feb868c94468d6fab05f535e198000000000200000000001066000000010000200000002aa496e945431d41 fe82e4e007773caf9379c1cbf563b7163689a5f752b325f5000000000e80000000020000200000007f1837b77634b506072902d0ea16276f66a6b7b05eec06979823d9271fe7 4975100000008a44ddb2f63d13dd1bf298bbc30b679240000000b94350179a432fc6ec084e2ee6ae9099963a82ee2768f8687309a59d8b371d337495240feb9efae58fba6945 9f4e018e070339798facebac15ba06ac845784dc

Si je vous dis que cette chaine de caractère ne correspond pas à l’exemple de code présent ici, vous devez uniquement me croire sur parole, car si on ne fournit pas de clé d’encryption ce qui est mon cas, la cmdlet se base sur les API Windows Data Protection, donc pour faire une conversation inverse, il faut faire celle ci sur la même machine avec le même utilisateur.


Cependant si vous voulez faire un ConvertBack, il est possible de le faire via ces différentes commandes Powershell :

$secureStringBack = $secureStringValue | ConvertTo-SecureString

$bstr = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureStringBack);
$finalValue = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($bstr)

Remonter

Créer des urls propres pour vos sites Web

AVRI29

Si comme moi, vous aimez voir des urls lisibles quand vous naviguez sur des sites, vous vous êtes déjà penchez sur la question sur comment formater votre url, afin qu’elle soit facilement lisible pour vos utilisateurs, et pour les moteurs de recherche.

 

Alors comme vous devez le savoir il y a la méthode UrlEncode disponible dans le Framework, mais personnellement je n’aime pas trop cette méthode, puisqu’elle vous traduit les caractères spéciaux en caractères encodés, ce que je ne trouve pas très lisible.

L’autre solution est de remplacer tous les caractères spéciaux par un autre caractère associé, en créant 2 listes, et en réalisant un mapping, mais il suffit que vous oubliez un caractère spécial, et c’est le drame !

 

La dernière solution, c’est de réaliser une normalisation de votre chaîne de caractères, et de garder uniquement les caractères qui vous intéressent, voici donc la méthode que j’utilise pour mon blog :

 

public static string GenerateShortName(this string valueToConvert)
{
    StringBuilder sb = new StringBuilder();
    string st = valueToConvert.ToLower().Normalize(NormalizationForm.FormD);

    foreach (char t in st)
    {
        System.Globalization.UnicodeCategory uc = System.Globalization.CharUnicodeInfo.GetUnicodeCategory(t);
        switch (uc)
        {
            case System.Globalization.UnicodeCategory.LowercaseLetter:
            case System.Globalization.UnicodeCategory.DecimalDigitNumber:
                sb.Append(t);
                break;
            case System.Globalization.UnicodeCategory.SpaceSeparator:
                if (sb.ToString().LastOrDefault() != '-')
                    sb.Append('-');
                break;
            default:
                break;
        }
    }

    string value = sb.ToString().Normalize(NormalizationForm.FormC);

    return value;
}

Alors si on prend comme exemple le texte suivant : “Unity : Gestion des paramètres primitifs”, regardons ce que ça donne lorsqu’on l’encode, où que l’on utilise cette méthode.

image

A mon sens, le résultat est sans appel, mais je ne suis pas  à 100% objectif !

Et voilà, même près tout ce temps, le Framework .Net peut vous apprendre énormément de choses !


Remonter

Unity : Gestion des paramètres primitifs

AVRI28

On a vu précédemment qu’avec de l’IoC comme Unity, il est facilement possible d’instancier des objets avec des paramètres complexes qui ont été au préalable enregistrés dans Unity. Cependant, il est aussi possible de résoudre des objets qui contiennent des types primitifs

Pour un cas concret, prenons ce code qui contient des paramètres optionnels.

public class MyClass : IMyInterface
{
    public MyClass(string param1, int param2, string param3 = "test", int param4 = 42)
    {
        Console.WriteLine("Params : {0}, {1}, {2}, {3}", param1, param2, param3, param4);
    }
}

Si l’on souhaite résoudre via Unity cette classe, il nous faut donc définir les paramètres, pour cela nous allons utiliser la classe ParametersOverride pour passer nos paramètres lors de la résolution de notre classe.

UnityRoot.Container.Resolve<IMyInterface>(new ParameterOverrides()
                                              {
                                                  {"param1", "val"},
                                                  {"param2", 3},
                                                  {"param3", "toto"},
                                                  {"param4", 12}
                                              });

 

Ainsi lors de la résolution de notre container, nous aurons bien la valeur de nos 4 paramètres.

image

 

Alors, comme vous avez pu le voir, dans mon exemple j’ai indiqué des paramètres optionnels, que j’ai néanmoins voulu résoudre lors de l’instanciation de ma classe. Parce qu’en effet à ce jour, Unity ne gère pas les paramètres optionnels, c’est à dire que si je souhaite résoudre ma classe de cette façon :

UnityRoot.Container.Resolve<IMyInterface>(new ParameterOverrides()
                                              {
                                                  {"param1", "val"},
                                                  {"param2", 3}
                                              });

Il se produira une erreur de type Microsoft.Practices.Unity.ResolutionFailedException car celui-ci n’arrive pas à résoudre les paramètres optionnels, comme on peut le voir ci-dessous

image

 

Donc mon conseil, soit vous passez par des propriétés que vous injectez, ce qui vous évite d’avoir des paramètres optionnels que vous devez absolument saisir. Soit vous pouvez définir tous vos paramètres de façon non optionnel.


Remonter

Mon nouveau blog

AVRI27

Vu que j’en avais parlé il y a quelques temps voici mon nouveau blog !

Déjà pourquoi je voulais changer ? Et bien tout simplement, je voulais avoir la main sur mon hébergement, ainsi que sur l’applicatif, donc j’ai décidé d’entièrement le refaire ! De plus, j’ai eu pas mal de problème de latence avec mon ancien blog que je ne vais plus avoir à ce jour !

 

Un petit résumé de ce qui se trouve derrière, si cela vous intéresse :

  • Windows Azure
  • ASP.Net MVC 3
  • Razor
  • Table Storage

 

Et c’est un super blog, sans aucun back office, tout est intégralement gérer via le protocole XML Rpc, et je peux donc tout éditer par Live Writer !

Pour le moment ça tourne sur une simple instance Extra Small ! Donc si vous trouvez qu’il est trop lent à répondre, n’hésitez pas à me le dire, histoire que j’augmente le nombre d’instance !

Voilà un grand merci à Aurélie Durdux qui travaille sur le design, et l’intégration du site !


Remonter

Unity : Enregistrer des types génériques et les résoudre

MARS15

Bon une fois n’est pas coutume, cela fait vraiment longtemps que je n’ai pas publié un billet n’ayant pas de rapport avec la plateforme Windows Azure. Même si j’avoue que je viens d’utiliser cette astuce dans la future version de mon blog sur Azure, mais vous en serez plus très bientôt j’espère !

 

Alors ma problématique est la suivante, je souhaitais faire un cache générique pour mon application, et bien entendu, j’utilise Unity dans tous mes projets, et donc celui ci ne fait pas exception à la règle. J’ai donc cherché à résoudre mes dépendances selon le type dont j’ai besoin.

 

On va donc commencer par créer une interface générique comme celle-ci  :

  1. public interface MyGenericInterface<T>
  2. {
  3.     void DisplayType(T instance);
  4. }

 

On va ensuite l’implémenter dans une classe :

  1. public class MyClass : MyGenericInterface<String>
  2. {
  3.     public void DisplayType(String instance)
  4.     {
  5.         Console.WriteLine(instance.GetType().FullName + Environment.NewLine);
  6.     }
  7. }

 

Voyons maintenant comment l’enregistrer dans un conteneur Unity :

  1. private static void Configure(IUnityContainer container)
  2. {
  3.     container.RegisterType(typeof (MyGenericInterface<>), typeof(MyClass));
  4. }

Comme on peut le voir, on enregistre les types de façon assez classique, il nous faut juste ajout les chevrons afin de définir un paramètre générique.

Si par hasard, vous avez plusieurs paramètres, par exemple, il faudra faire comme ci-dessous afin de définir qu’il y a bien 3 paramètres génériques

  1. private static void Configure(IUnityContainer container)
  2. {
  3.     container.RegisterType(typeof (MyGenericInterface<,,>), typeof(MyClass));
  4. }

 

Et maintenant, voyons comment résoudre nos types, si on prend l’exemple suivant :

  1. UnityRoot.EnsureInitialized();
  2. UnityRoot.Container.Resolve<MyGenericInterface<String>>().DisplayType("Hello");
  3.  
  4. try
  5. {
  6.     UnityRoot.Container.Resolve<MyGenericInterface<Int32>>().DisplayType(42);
  7. }
  8. catch (Exception ex)
  9. {
  10.     Console.ForegroundColor = ConsoleColor.Red;
  11.     Console.WriteLine(ex);
  12.     Console.ForegroundColor = ConsoleColor.White;
  13. }

 

On va donc essayer de résoudre une classe implémentant notre interface avec le type String, et ensuite avec le type Int32. Dans notre cas, nous n’avons ajouté qu’une classe avec une interface avec le type String.

Si nous lançons notre application, nous allons donc avoir ceci  :

image

 

Nous avons bien la résolution de notre premier élément, par contre la deuxième ne marche pas comme prévu, puisque nous n’avons pas enregistrer de classe avec notre interface implémentant le type Int32.

Voilà, je ne vous donne pas le code source de la solution, puisque tout est là, il ne manque que les références à Unity, et pour cela NuGet est votre meilleur ami !


Remonter

© Wilfried Woivré, tous droits réservés mai 2018