Exporter (0) Imprimer
Développer tout
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

Procédure : Créer une bibliothèque de cryptage

Dernière mise à jour le 31 août 2004
Sur cette page

Objectifs Objectifs
S'applique à S'applique à
Résumé Résumé
Créer une bibliothèque de classes Visual C# Créer une bibliothèque de classes Visual C#
Créer une application de test de console Créer une application de test de console
Ressources supplémentaires Ressources supplémentaires

Objectifs

Ce module vous permet d'effectuer les opérations suivantes :

  • créer une bibliothèque de cryptage générique destinée à crypter et décrypter les données selon les systèmes DES (Digital Encryption Standard), Tripe DES, Rijndeal ou RC2 ;

  • utiliser la bibliothèque de cryptage à partir de vos applications.

S'applique à

Ce module s'applique aux produits et technologies suivants :

  • Microsoft Windows® XP ou Windows 2000 Server (avec le Service Pack 3) et systèmes d'exploitation ultérieurs

  • .NET Framework version 1.0 (avec le Service Pack 2) et versions ultérieures

  • Microsoft Visual C#® .NET

Résumé

L'environnement Microsoft® .NET Framework prend en charge un large éventail d'algorithmes de cryptage symétrique, parmi ceux qui sont les plus employés. Les classes représentant ces algorithmes sont bien structurées et peuvent être utilisées selon le même modèle. Au lieu d'écrire du code dans chaque application pour effectuer le cryptage et le décryptage des données confidentielles, vous pouvez ainsi créer facilement une bibliothèque réutilisable permettant de réaliser ces opérations à l'aide des algorithmes symétriques disponibles. Ce module décrit comment créer une telle bibliothèque.

Créer une bibliothèque de classes Visual C#

Cette procédure permet de créer une bibliothèque de classes Visual C#, qui fournira des fonctionnalités de cryptage et de décryptage.

  • Pour créer une bibliothèque de classes Visual C#

    1. Démarrez Visual Studio .NET et créez un projet de bibliothèque de classes Visual C# nommé Encryption.

    2. Utilisez l'Explorateur de solutions pour renommer class1.cs en EncryptTransformer.cs.

    3. Dans EncryptTransformer.cs, renommez Class1 en EncryptTransformer.

    4. Remplacez la portée de la classe public par internal.

      internal class EncryptTransformer
      
    5. Ajoutez l'instruction using suivante en haut du fichier.

      using System.Security.Cryptography;
      
    6. Ajoutez le type énuméré suivant à l'espace de noms Encryption.

      public enum EncryptionAlgorithm {Des = 1, Rc2, Rijndael, TripleDes};
      
    7. Ajoutez les deux variables de membre privé suivantes à la classe EncryptTransformer.

      private EncryptionAlgorithm algorithmID;
      private byte[] initVec;
      private byte[] encKey;
      
    8. Remplacez le constructeur par défaut par le constructeur suivant.

      internal EncryptTransformer(EncryptionAlgorithm algId)
      {
        //Enregistrer l'algorithme utilisé.
        algorithmID = algId;
      }
      
    9. Ajoutez la méthode suivante à la classe.

      internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
      {
        // Sélectionner le fournisseur.
        switch (algorithmID)
        {
          case EncryptionAlgorithm.Des:
          {
            DES des = new DESCryptoServiceProvider();
            des.Mode = CipherMode.CBC;
      
            // Vérifier si une clé a été fournie.
            if (null == bytesKey)
            {
              encKey = des.Key;
            }
            else
            {
              des.Key = bytesKey;
              encKey = des.Key;
            }
            // Vérifier si le client a fourni un vecteur d'initialisation.
            if (null == initVec)
            { // Demander à l'algorithme d'en créer un.
              initVec = des.IV;
            }
            else
            { //Non, le fournir à l'algorithme.
              des.IV = initVec;
            }
            return des.CreateEncryptor();
          }
          case EncryptionAlgorithm.TripleDes:
          {
            TripleDES des3 = new TripleDESCryptoServiceProvider();
            des3.Mode = CipherMode.CBC;
            // Vérifier si une clé a été fournie.
            if (null == bytesKey)
            {
              encKey = des3.Key;
            }
            else
            {
              des3.Key = bytesKey;
              encKey = des3.Key;
            }
            // Vérifier si le client a fourni un vecteur d'initialisation.
            if (null == initVec)
            { //Oui, demander à l'algo. d'en créer un.
              initVec = des3.IV;
            }
            else
            { //Non, le fournir à l'algo.
              des3.IV = initVec;
            }
            return des3.CreateEncryptor();
          }
          case EncryptionAlgorithm.Rc2:
          {
            RC2 rc2 = new RC2CryptoServiceProvider();
            rc2.Mode = CipherMode.CBC;
            // Vérifier si une clé a été fournie.
            if (null == bytesKey)
            {
              encKey = rc2.Key;
            }
            else
            {
              rc2.Key = bytesKey;
              encKey = rc2.Key;
            }
            // Vérifier si le client a fourni un vecteur d'initialisation.
            if (null == initVec)
            { //Oui, demander à l'algo. d'en créer un.
              initVec = rc2.IV;
            }
            else
            { //Non, le fournir à l'algo.
              rc2.IV = initVec;
            }
            return rc2.CreateEncryptor();
          }
          case EncryptionAlgorithm.Rijndael:
          {
            Rijndael rijndael = new RijndaelManaged();
            rijndael.Mode = CipherMode.CBC;
            // Vérifier si une clé a été fournie.
            if(null == bytesKey)
            {
              encKey = rijndael.Key;
            }
            else
            {
              rijndael.Key = bytesKey;
              encKey = rijndael.Key;
            }
            // Vérifier si le client a fourni un vecteur d'initialisation.
            if(null == initVec)
            { //Oui, demander à l'algo. d'en créer un.
              initVec = rijndael.IV;
            }
            else
            { //Non, le fournir à l'algo.
              rijndael.IV = initVec;
            }
            return rijndael.CreateEncryptor();
          } 
          default:
          {
            throw new CryptographicException("ID de l'algorithme '" + algorithmID + 
                                             "' non pris en charge.");
          }
        }
      }
      
    10. Ajoutez les propriétés suivantes à la classe.

      internal byte[] IV
      {
        get{return initVec;}
        set{initVec = value;}
      }
      internal byte[] Key
      {
        get{return encKey;}
      }
      
    11. Ajoutez une nouvelle classe nommée DecryptTransformer au projet.

    12. Ajoutez l'instruction using suivante en haut du fichier DecryptTransformer.cs.

      using System.Security.Cryptography;
      
    13. Remplacez la portée de la classe public par internal.

    14. Remplacez le constructeur par défaut par le constructeur suivant.

      internal DecryptTransformer(EncryptionAlgorithm deCryptId)
      {
        algorithmID = deCryptId;
      }
      
    15. Ajoutez les variables privées suivantes à la classe.

      private EncryptionAlgorithm algorithmID;
      private byte[] initVec;
      
    16. Ajoutez la méthode suivante à la classe.

      internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
      {
        // Sélectionner le fournisseur.
        switch (algorithmID)
        {
          case EncryptionAlgorithm.Des:
          {
            DES des = new DESCryptoServiceProvider();
            des.Mode = CipherMode.CBC;
            des.Key = bytesKey;
            des.IV = initVec;
            return des.CreateDecryptor();
          }
          case EncryptionAlgorithm.TripleDes:
          {
            TripleDES des3 = new TripleDESCryptoServiceProvider();
            des3.Mode = CipherMode.CBC;
            return des3.CreateDecryptor(bytesKey, initVec);
          }
          case EncryptionAlgorithm.Rc2:
          {
            RC2 rc2 = new RC2CryptoServiceProvider();
            rc2.Mode = CipherMode.CBC;
            return rc2.CreateDecryptor(bytesKey, initVec);
          }
          case EncryptionAlgorithm.Rijndael:
          {
            Rijndael rijndael = new RijndaelManaged();
            rijndael.Mode = CipherMode.CBC;
            return rijndael.CreateDecryptor(bytesKey, initVec);
          } 
          default:
          {
            throw new CryptographicException("ID de l'algorithme '" + algorithmID + 
                                             "' non pris en charge.");
          }
        }
      } //end GetCryptoServiceProvider
      
    17. Ajoutez la propriété suivante à la classe.

      internal byte[] IV
      {
        set{initVec = value;}
      }
      
    18. Ajoutez une nouvelle classe nommée Encryptor au projet.

    19. Ajoutez les instructions using suivantes en haut du fichier Encryptor.cs.

      using System.Security.Cryptography;
      using System.IO;
      
    20. Remplacez le constructeur par défaut par le constructeur suivant.

      public Encryptor(EncryptionAlgorithm algId)
      {
        transformer = new EncryptTransformer(algId);
      }
      
    21. Ajoutez les variables de membre privé suivantes à la classe.

      private EncryptTransformer transformer;
      private byte[] initVec;
      private byte[] encKey;
      
    22. Ajoutez la méthode Encrypt suivante à la classe.

      public byte[] Encrypt(byte[] bytesData, byte[] bytesKey)
      {
        //Configurer le flux qui contiendra les données cryptées.
        MemoryStream memStreamEncryptedData = new MemoryStream();
      
        transformer.IV = initVec;
        ICryptoTransform transform = transformer.GetCryptoServiceProvider
        (bytesKey);
        CryptoStream encStream = new CryptoStream(memStreamEncryptedData, 
                                                  transform, 
                                                  CryptoStreamMode.Write);
        try
        {
          //Crypter les données, les écrire dans le flux de mémoire.
          encStream.Write(bytesData, 0, bytesData.Length);
        }
        catch(Exception ex)
        {
          throw new Exception("Erreur lors de l'écriture des données cryptées dans le flux : \n" 
                              + ex.Message);
        }
        //Définir le vecteur d'initialisation et la clé à récupérer par le client.
        encKey = transformer.Key;
        initVec = transformer.IV;
        encStream.FlushFinalBlock();
        encStream.Close();
      
        //Renvoyer les données.
        return memStreamEncryptedData.ToArray();
      }//end Encrypt
      
    23. Ajoutez les propriétés suivantes à la classe.

      public byte[] IV
      {
        get{return initVec;}
        set{initVec = value;}
      }
      
      public byte[] Key
      {
        get{return encKey;}
      }
      
    24. Ajoutez une nouvelle classe nommée Decryptor au projet.

    25. Ajoutez les instructions using suivantes en haut du fichier Decryptor.cs.

      using System.Security.Cryptography;
      using System.IO;
      
    26. Remplacez le constructeur par défaut par le constructeur suivant.

      public Decryptor(EncryptionAlgorithm algId)
      {
        transformer = new DecryptTransformer(algId);
      }
      
    27. Ajoutez les variables de membre privé suivantes à la classe.

      private DecryptTransformer transformer;
      private byte[] initVec;
      
    28. Ajoutez la méthode Decrypt suivante à la classe.

      public byte[] Decrypt(byte[] bytesData, byte[] bytesKey)
      {
        //Configurer le flux de mémoire pour les données décryptées.
        MemoryStream memStreamDecryptedData = new MemoryStream();
      
        //Transmettre le vecteur d'initialisation.
        transformer.IV = initVec;
        ICryptoTransform transform = transformer.GetCryptoServiceProvider
        (bytesKey);
        CryptoStream decStream = new CryptoStream(memStreamDecryptedData, 
                                                  transform, 
                                                  CryptoStreamMode.Write);
        try
        {
          decStream.Write(bytesData, 0, bytesData.Length);
        }
        catch(Exception ex)
        {
          throw new Exception("Erreur lors de l'écriture des données cryptées dans le 
          flux : \n" 
                              + ex.Message);
        }
        decStream.FlushFinalBlock();
        decStream.Close();
        // Renvoyer les données.
        return memStreamDecryptedData.ToArray();
      } //end Decrypt
      
    29. Ajoutez la propriété suivante à la classe.

      public byte[] IV
      {
        set{initVec = value;}
      }
      
    30. Dans le menu Générer, choisissez Générer la solution.

Créer une application de test de console

Cette procédure permet de créer une application de test de console simple pour tester les fonctionnalités de cryptage et de décryptage.

  • Pour créer une application de test de console

    1. Ajoutez une nouvelle application console Visual C# Visual nommée EncryptionTester à la solution actuelle.

    2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet EncryptionTester et cliquez sur Définir comme projet de démarrage.

    3. Utilisez l'Explorateur de solutions pour renommer class1.cs en EncryptionTest.cs.

    4. Dans EncryptionTest.cs, renommez Class1 en EncryptionTest.

    5. Ajoutez une référence de projet au projet Encryption.

    6. Ajoutez les instructions using suivantes en haut du fichier EncryptionTest.cs.

      using System.Text;
      using Encryption;
      
    7. Ajoutez le code suivant à la méthode Main.

      // Définir l'algorithme nécessaire.
      EncryptionAlgorithm algorithm = EncryptionAlgorithm.Des;
      
      // Init variables.
      byte[] IV = null;
      byte[] cipherText = null;
      byte[] key = null;
      
      try
      { //Essayer de crypter.
        //Créer l'objet Encryptor.
        Encryptor enc = new Encryptor(EncryptionAlgorithm.Des);
        byte[] plainText = Encoding.ASCII.GetBytes("Tester la chaîne.");
      
        if ((EncryptionAlgorithm.TripleDes == algorithm) || 
            (EncryptionAlgorithm.Rijndael == algorithm))
        { //3Des fonctionne uniquement avec une clé de 16 ou de 24 octets.
          key = Encoding.ASCII.GetBytes("password12345678");
          if (EncryptionAlgorithm.Rijndael == algorithm)
          { // Doit comporter 16 octets pour Rijndael.
            IV = Encoding.ASCII.GetBytes("Le vecteur d'init. est grand.");
          }
          else
          {
            IV = Encoding.ASCII.GetBytes("vect. d'init.");
          }
        }
        else
        { //Des fonctionne uniquement avec une clé de 8 octets. Les autres systèmes utilisent des clés de longueur variable.
          //Attribuer la valeur null à la clé pour en générer une nouvelle.
          key = Encoding.ASCII.GetBytes("password");
          IV = Encoding.ASCII.GetBytes("vect. d'init.");
        }
        // Supprimer les deux barres obliques de commentaires dans les lignes suivantes pour que la clé ou le vecteur d'initialisation (IV) soit généré automatiquement.
        // key = null;
        // IV = null;
      
        enc.IV = IV;
      
        // Effectuer le cryptage..
        cipherText = enc.Encrypt(plainText, key);
        // Extraire le vecteur d'initialisation ou la clé. Vous en aurez besoin 
        // pour le décryptage..
        IV = enc.IV;
        key = enc.Key;
      
        // Consulter le texte chiffré et le vecteur d'initialisation.
        Console.WriteLine("          Texte chiffré : " + 
                          Convert.ToBase64String(cipherText));
        Console.WriteLine("Vecteur d'initialisation : " + Convert.ToBase64
        String(IV));
        Console.WriteLine("                  Key: " + Convert.ToBase64
        String(key));
      }
      catch(Exception ex)
      {
        Console.WriteLine("Exception liée au cryptage. " + ex.Message);
        return;
      }
      try
      { //Essayer de décrypter.
        //Configurer le décryptage, lui associer l'algorithme et le vecteur d'initialisation.
        Decryptor dec = new Decryptor(algorithm);
        dec.IV = IV;
        // Continuer et décrypter.
        byte[] plainText = dec.Decrypt(cipherText, key);
        // Consulter le texte brut.
        Console.WriteLine("           Texte brut : " + 
                          Encoding.ASCII.GetString(plainText));
      }
      catch(Exception ex)
      {
        Console.WriteLine("Exception liée au décryptage. " + ex.Message);
        return;
      }
      
    8. Dans le menu Générer, choisissez Générer la solution.

    9. Exécutez l'application de test pour vérifier le fonctionnement des classes Encryptor et Decryptor.

Ressources supplémentaires

Pour plus d'informations, consultez la section « Procédure : Stocker une chaîne de connexion cryptée dans le Registre ».

Cela vous a-t-il été utile ?
(1500 caractères restants)
Merci pour vos suggestions.
Afficher:
© 2014 Microsoft. Tous droits réservés.