Crittografia

Avviare Visual Studio .NET e creare un nuovo progetto Libreria di classi Visual C# denominato Encryption.

Utilizzare Esplora soluzioni per rinominare class1.cs come EncryptTransformer.cs.

In EncryptTransformer.cs rinominare Class1 come EncryptTransformer.

Modificare l'ambito della classe da public a internal.

internal class EncryptTransformer 

Aggiungere la seguente istruzione using all'inizio del file.

using System.Security.Cryptography; 

Aggiungere il tipo enumerato riportato di seguito all'interno dello spazio dei nomi Encryption.

public enum EncryptionAlgorithm {Des = 1, Rc2, Rijndael, TripleDes}; 

Aggiungere le variabili membro private riportate di seguito alla classe EncryptTransformer.

private EncryptionAlgorithm algorithmID; 
private byte[] initVec; 
private byte[] encKey; 

Sostituire il costruttore predefinito con il seguente:

internal EncryptTransformer(EncryptionAlgorithm algId) 
{ 
  //Save the algorithm being used. 
  algorithmID = algId; 
} 

Aggiungere alla classe il seguente metodo:

internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey) 
{ 
  // Pick the provider. 
  switch (algorithmID) 
  { 
    case EncryptionAlgorithm.Des: 
    { 
      DES des = new DESCryptoServiceProvider(); 
      des.Mode = CipherMode.CBC; 
      // See if a key was provided 
      if (null == bytesKey) 
      { 
        encKey = des.Key; 
      } 
      else 
      { 
        des.Key = bytesKey; 
        encKey = des.Key; 
      } 
      // See if the client provided an initialization vector 
      if (null == initVec) 
      { // Have the algorithm create one 
        initVec = des.IV; 
      } 
      else 
      { //No, give it to the algorithm 
        des.IV = initVec; 
      } 
      return des.CreateEncryptor(); 
    } 
    case EncryptionAlgorithm.TripleDes: 
    { 
      TripleDES des3 = new TripleDESCryptoServiceProvider(); 
      des3.Mode = CipherMode.CBC; 
      // See if a key was provided 
      if (null == bytesKey) 
      { 
        encKey = des3.Key; 
      } 
      else 
      { 
        des3.Key = bytesKey; 
        encKey = des3.Key; 
      } 
      // See if the client provided an IV 
      if (null == initVec) 
      { //Yes, have the alg create one 
        initVec = des3.IV; 
      } 
      else 
      { //No, give it to the alg. 
        des3.IV = initVec; 
      } 
      return des3.CreateEncryptor(); 
    } 
    case EncryptionAlgorithm.Rc2: 
    { 
      RC2 rc2 = new RC2CryptoServiceProvider(); 
      rc2.Mode = CipherMode.CBC; 
      // Test to see if a key was provided 
      if (null == bytesKey) 
      { 
        encKey = rc2.Key; 
      } 
      else 
      { 
        rc2.Key = bytesKey; 
        encKey = rc2.Key; 
      } 
      // See if the client provided an IV 
      if (null == initVec) 
      { //Yes, have the alg create one 
        initVec = rc2.IV; 
      } 
      else 
      { //No, give it to the alg. 
        rc2.IV = initVec; 
      } 
      return rc2.CreateEncryptor(); 
    } 
    case EncryptionAlgorithm.Rijndael: 
    { 
      Rijndael rijndael = new RijndaelManaged(); 
      rijndael.Mode = CipherMode.CBC; 
      // Test to see if a key was provided 
      if(null == bytesKey) 
      { 
        encKey = rijndael.Key; 
      } 
      else 
      { 
        rijndael.Key = bytesKey; 
        encKey = rijndael.Key; 
      } 
      // See if the client provided an IV 
      if(null == initVec) 
      { //Yes, have the alg create one 
        initVec = rijndael.IV; 
      } 
      else 
      { //No, give it to the alg. 
        rijndael.IV = initVec; 
      } 
      return rijndael.CreateEncryptor(); 
    }  
    default: 
    { 
      throw new CryptographicException("Algorithm ID '" + algorithmID +  
                                       "' not supported."); 
    } 
  } 
} 

Aggiungere alla classe le seguenti proprietà:

internal byte[] IV 
{ 
  get{return initVec;} 
  set{initVec = value;} 
} 
internal byte[] Key 
{ 
  get{return encKey;} 
} 

Aggiungere una nuova classe denominata DecryptTransformer al progetto.

Aggiungere la seguente istruzione using all'inizio del file DecryptTransformer.cs.

using System.Security.Cryptography; 

Modificare l'ambito della classe da public a internal.

Sostituire il costruttore predefinito con il seguente:

internal DecryptTransformer(EncryptionAlgorithm deCryptId) 
{ 
  algorithmID = deCryptId; 
} 

Aggiungere alla classe le seguenti variabili private:

private EncryptionAlgorithm algorithmID; 
private byte[] initVec; 

Aggiungere alla classe il seguente metodo:

internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey) 
{ 
  // Pick the provider. 
  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("Algorithm ID '" + algorithmID +  
                                       "' not supported."); 
    } 
  } 
} //end GetCryptoServiceProvider 

Aggiungere alla classe la seguente proprietà:

internal byte[] IV 
{ 
  set{initVec = value;} 
} 

Aggiungere una nuova classe denominata Encryptor al progetto.

Aggiungere le seguenti istruzioni using all'inizio del file Encryptor.cs.

using System.Security.Cryptography; 
using System.IO; 

Sostituire il costruttore predefinito con il seguente:

public Encryptor(EncryptionAlgorithm algId) 
{ 
  transformer = new EncryptTransformer(algId); 
} 

Aggiungere alla classe le seguenti variabili membro private:

private EncryptTransformer transformer; 
private byte[] initVec; 
private byte[] encKey; 

Aggiungere alla classe il seguente metodo Encrypt:

public byte[] Encrypt(byte[] bytesData, byte[] bytesKey) 
{ 
  //Set up the stream that will hold the encrypted data. 
  MemoryStream memStreamEncryptedData = new MemoryStream(); 
  transformer.IV = initVec; 
  ICryptoTransform transform = transformer.GetCryptoServiceProvider 
  (bytesKey); 
  CryptoStream encStream = new CryptoStream(memStreamEncryptedData,  
                                            transform,  
                                            CryptoStreamMode.Write); 
  try 
  { 
    //Encrypt the data, write it to the memory stream. 
    encStream.Write(bytesData, 0, bytesData.Length); 
  } 
  catch(Exception ex) 
  { 
    throw new Exception("Error while writing encrypted data to the  
    stream: \n"  
                        + ex.Message); 
  } 
  //Set the IV and key for the client to retrieve 
  encKey = transformer.Key; 
  initVec = transformer.IV; 
  encStream.FlushFinalBlock(); 
  encStream.Close(); 
  //Send the data back. 
  return memStreamEncryptedData.ToArray(); 
}//end Encrypt 

Aggiungere alla classe le seguenti proprietà:

public byte[] IV 
{ 
  get{return initVec;} 
  set{initVec = value;} 
} 
public byte[] Key 
{ 
  get{return encKey;} 
} 

Aggiungere una nuova classe denominata Decryptor al progetto.

Aggiungere le seguenti istruzioni using all'inizio del file Decryptor.cs:

using System.Security.Cryptography; 
using System.IO; 

Sostituire il costruttore predefinito con il seguente:

public Decryptor(EncryptionAlgorithm algId) 
{ 
  transformer = new DecryptTransformer(algId); 
} 

Aggiungere alla classe le seguenti variabili membro private:

private DecryptTransformer transformer; 
private byte[] initVec; 

Aggiungere alla classe il seguente metodo Decrypt:

public byte[] Decrypt(byte[] bytesData, byte[] bytesKey) 
{ 
  //Set up the memory stream for the decrypted data. 
  MemoryStream memStreamDecryptedData = new MemoryStream(); 
  //Pass in the initialization vector. 
  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("Error while writing encrypted data to the  
    stream: \n"  
                        + ex.Message); 
  } 
  decStream.FlushFinalBlock(); 
  decStream.Close(); 
  // Send the data back. 
  return memStreamDecryptedData.ToArray(); 
} //end Decrypt 

Aggiungere alla classe la seguente proprietà:

public byte[] IV 
{ 
  set{initVec = value;} 
} 

Scegliere Genera soluzione dal menu Genera.

Aggiungere alla soluzione corrente una nuova applicazione console Visual C# denominata EncryptionTester.

In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto EncryptionTester, quindi scegliere Imposta come progetto di avvio.

Utilizzare Esplora soluzioni per rinominare class1.cs come EncryptionTest.cs.

In EncryptionTest.cs rinominare Class1 come EncryptionTest.

Aggiungere un riferimento al progetto nel progetto Encryption.

Aggiungere le seguenti istruzioni using all'inizio del file EncryptionTest.cs:

using System.Text; 
using Encryption; 

Aggiungere al metodo Main il seguente codice:

// Set the required algorithm 
EncryptionAlgorithm algorithm = EncryptionAlgorithm.Des; 
// Init variables. 
byte[] IV = null; 
byte[] cipherText = null; 
byte[] key = null; 
try 
{ //Try to encrypt. 
  //Create the encryptor. 
  Encryptor enc = new Encryptor(EncryptionAlgorithm.Des); 
  byte[] plainText = Encoding.ASCII.GetBytes("Test String"); 
  if ((EncryptionAlgorithm.TripleDes == algorithm) ||  
      (EncryptionAlgorithm.Rijndael == algorithm)) 
  { //3Des only work with a 16 or 24 byte key. 
    key = Encoding.ASCII.GetBytes("password12345678"); 
    if (EncryptionAlgorithm.Rijndael == algorithm) 
    { // Must be 16 bytes for Rijndael. 
      IV = Encoding.ASCII.GetBytes("init vec is big."); 
    } 
    else 
    { 
      IV = Encoding.ASCII.GetBytes("init vec"); 
    } 
  } 
  else 
  { //Des only works with an 8 byte key. The others uses variable  
  length  
  keys. 
    //Set the key to null to have a new one generated. 
    key = Encoding.ASCII.GetBytes("password"); 
    IV = Encoding.ASCII.GetBytes("init vec"); 
  } 
  // Uncomment the next lines to have the key or IV generated for you. 
  // key = null; 
  // IV = null; 
  enc.IV = IV; 
  // Perform the encryption. 
  cipherText = enc.Encrypt(plainText, key); 
  // Retrieve the intialization vector and key. You will need it  
  // for decryption. 
  IV = enc.IV; 
  key = enc.Key; 
  // Look at your cipher text and initialization vector. 
  Console.WriteLine("          Cipher text: " +  
                    Convert.ToBase64String(cipherText)); 
  Console.WriteLine("Initialization vector: " + Convert.ToBase64 
  String(IV)); 
  Console.WriteLine("                  Key: " + Convert.ToBase64 
  String(key)); 
} 
catch(Exception ex) 
{ 
  Console.WriteLine("Exception encrypting. " + ex.Message); 
  return; 
} 
try 
{ //Try to decrypt. 
  //Set up your decryption, give it the algorithm and initialization  
  vector. 
  Decryptor dec = new Decryptor(algorithm); 
  dec.IV = IV; 
  // Go ahead and decrypt. 
  byte[] plainText = dec.Decrypt(cipherText, key); 
  // Look at your plain text. 
  Console.WriteLine("           Plain text: " +  
                    Encoding.ASCII.GetString(plainText)); 
} 
catch(Exception ex) 
{ 
  Console.WriteLine("Exception decrypting. " + ex.Message); 
  return; 
} 

Scegliere Genera soluzione dal menu Genera.

Eseguire l'applicazione di prova per verificare il funzionamento delle classi Encryptor e Decryptor.