Wie viele Zeichen ein Byte-Array für meine AES-Methode zu schaffen?

Question

Ich bin mit dem AES-Verfahren hier: http : //msdn.microsoft.com/en-us/library/system.security.cryptography.rijndaelmanaged.aspx

Ich möchte einen String-Wert haben, die ich auf Byte-Array umwandeln und an die AES verschlüsseln Methode übergeben. Wie viele Zeichen sollte die Zeichenfolge die richtigen Byte-Array-Größe zu erzeugen, die die Methode erwartet?

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

Die Größe des Klartexts spielt keine Rolle. So stellen Sie sicher, dass Sie genau die gleiche IV und Schlüssel zusammen mit den verschlüsselten Bytes in den decryptStringFromBytes_AES verwenden (byte [] chiffrierten Text, byte [] Key, byte [] IV) Verfahren. Das wird die eingegebene Klartext an Sie zurück zurück.

Zum Beispiel:

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);

Hier sollten Sie sehen, dass Klartext und Klartext-wieder gleich sind. Nun gehen Sie vor und ändern plain_text zu, was Sie wollen und sehen, dass das funktioniert gut.

Die Standardwerte für RijndaelManaged sind:
Blockgröße: 128
KeySize: 256
Modus: CipherMode.CBC
Padding: PaddingMode.PKCS7

Die gültigen IV Größen sind:
128, 192, 256 Bits (Dies ist die Blockgröße ist, stellen Sie sicher, dass es von der Größe IV einstellen Sie verwenden)
Die gültigen Schlüsselgrößen sind:
128, 192, 256 Bits (Dies ist die KeySize, stellen Sie sicher, dass es auf die Größe Schlüssel setzen Sie verwenden)

Das bedeutet, dass das byte [] IV 16 sein kann, 24 oder 32 Byte (in meinem obigen Beispiel seines 16 Bytes) und die Byte-Taste [] kann auch 16, 24 oder 32 Bytes sein (in meinem obigen Beispiel seine 16 Bytes).

Ich hoffe, das hilft.

Answer 2

Sie müssen Polsterung dafür. Eigentlich ist die Seite, die Sie hat ein Beispiel auf padding verknüpft (in C ++).

Mit Polsterungen, können Sie Nicht-Standard-Blockgrößen verschlüsseln.

Answer 3

Sie einen String in seine Unicode-Byte-Darstellung nicht konvertieren. Sie wird zu hart sein für die richtige Länge zu überprüfen, und nicht genug Randomisierung liefern.

könnten Sie folgendermaßen vorgehen: Verwenden Sie eine Schlüsselableitungsfunktion . Sie wollen einen Byte-Array mit fester Länge für die Eingabe der Funktion. Dies ist, was RFC2898 ist am besten.

So erstellen Sie ein neues RFC2898 Objekt:

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.
        // ...
    }
}

Für ein Beispiel dafür, wie ich diese verwendet haben, überprüfen mein Projekt Rijndael mit . Ich habe ein Passwort Schritt, in dem ich eine Zeichenfolge nehmen und die Schlüssel und iv Byte-Arrays unter Verwendung des oben genannten Verfahrens erhalten.