Combien de caractères pour créer un tableau d'octets pour ma méthode AES?

Question

J'utilise les méthodes AES ici: http://msdn.microsoft.com/en-us/library/system.security.cryptography.rijndaelmanaged.aspx

Je veux avoir une valeur de chaîne que je convertir en tableau d'octets et de le transmettre à la méthode de chiffrement AES. Combien de caractères doit être la chaîne pour produire la taille de tableau d'octets correcte attendue par la méthode?

static byte[] encryptStringToBytes_AES(string plainText, byte[] Key, byte[] IV) 
    { 
     // Check arguments. 
     if (plainText == null || plainText.Length <= 0) 
      throw new ArgumentNullException("plainText"); 
     if (Key == null || Key.Length <= 0) 
      throw new ArgumentNullException("Key"); 
     if (IV == null || IV.Length <= 0) 
      throw new ArgumentNullException("Key"); 

     // Declare the stream used to encrypt to an in memory 
     // array of bytes. 
     MemoryStream msEncrypt = null; 

     // Declare the RijndaelManaged object 
     // used to encrypt the data. 
     RijndaelManaged aesAlg = null; 

     try 
     { 
      // Create a RijndaelManaged object 
      // with the specified key and IV. 
      aesAlg = new RijndaelManaged(); 
      aesAlg.Key = Key; 
      aesAlg.IV = IV; 

      // Create a decrytor to perform the stream transform. 
      ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); 

      // Create the streams used for encryption. 
      msEncrypt = new MemoryStream(); 
      using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) 
      { 
       using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) 
       { 

        //Write all data to the stream. 
        swEncrypt.Write(plainText); 
       } 
      } 

     } 
     finally 
     { 

      // Clear the RijndaelManaged object. 
      if (aesAlg != null) 
       aesAlg.Clear(); 
     } 

     // Return the encrypted bytes from the memory stream. 
     return msEncrypt.ToArray(); 

    } 

Answer 1

La taille du texte brut n'a pas d'importance. Assurez-vous juste d'utiliser la même IV et la même clé avec les octets cryptés dans la méthode decryptStringFromBytes_AES (byte [] cipherText, byte [] Key, byte [] IV). Cela vous retournera le texte brut entré.

Par exemple:

string plain_text = "Cool this works"; 
byte[] iv = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 
              0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}; 
byte[] key = new byte[] { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 
              0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF }; 
byte[] encrytped_text = encryptStringToBytes_AES(plain_text, key, iv); 
string plain_text_again = decryptStringFromBytes_AES(encrypted_text, key, iv); 

Ici, vous devriez voir que texte brut et encore-texte clair sont les mêmes. Maintenant allez-y et changez plain_text à tout ce que vous voulez et voyez que cela fonctionne bien.

Les valeurs par défaut pour RijndaelManaged sont:
BlockSize: 128
KeySize: 256
Mode: CipherMode.CBC
Rembourrage: PaddingMode.PKCS7

Les tailles valides IV sont:
128, 192, 256 bits (Ceci est le BlockSize, assurez-vous de le définir à la taille IV que vous utilisez)
Les tailles de clé valides sont:
128, 192, 256 bits (Ceci est la KeySize, m Veillez à le régler sur la clé de taille que vous utilisez)

Cela signifie que l'octet [] iv peut être de 16, 24 ou 32 octets (dans mon exemple ci-dessus ses 16 octets) et la touche d'octet [] peut également être 16, 24 ou 32 octets (dans mon exemple ci-dessus ses 16 octets).

Espérons que ça aide.

Answer 2

Vous avez besoin de remplissage pour cela. En fait, la page que vous avez liée a un exemple sur le remplissage (en C++).

Avec les paddings, vous pouvez crypter des tailles de bloc non standard.

Answer 3

Ne pas convertir une chaîne en sa représentation d'octet Unicode. Il sera trop difficile de vérifier la bonne longueur et de ne pas fournir assez de randomisation.

Vous pouvez effectuer les opérations suivantes: utiliser un key derivation function. Vous voulez un tableau d'octets de longueur fixe pour l'entrée de la fonction. C'est ce que Rfc2898 est le meilleur.

, créez un nouvel objet Rfc2898:

using PBKDF2 = System.Security.Cryptography.Rfc2898DeriveBytes; 

class Example { 
    byte[] mySalt = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 }; 

    void Initialize(string password) { 
     PBKDF2 kdf = new PBKDF2(password, mySalt); 
     // Then you have your algorithm 
     // When you need a key: use: 
     byte[] key = kdf.GetBytes(16); // for a 128-bit key (16*8=128) 

     // You can specify how many bytes you need. Same for IV. 
     byte[] iv = kdf.GetBytes(16); // 128 bits again. 

     // And then call your constructor, etc. 
     // ... 
    } 
} 

Pour un exemple de la façon dont je l'ai utilisé ce, consultez my project using Rijndael. J'ai une étape de mot de passe où je prends une chaîne et obtiens la clé et les tableaux d'octets iv en utilisant la méthode ci-dessus.