Generierung AES-256-bit-Schlüssel Wert

Kennt jemand eine Möglichkeit, um eine 256-bit-Schlüssel generierte Wert von einem pass phrase von jeder beliebigen Länge? Die Verschlüsselung kann nicht gesalzen werden, da die verschlüsselten Werte müssen neu generiert werden, verglichen und in der Datenbank. So einen Wert generieren muss, die die gleiche verschlüsselte Zeichenfolge jedes mal, wenn es verschlüsselt ist.

Derzeit bin ich mit einem 32-char key arbeiten an der möglicherweise falschen Annahme, dieser ist 256 bit?

So, ich würde wollen, dass 'the quick brown fox' umgewandelt werden, um einen geeigneten AES-256-bit-Schlüssel?

"Die Verschlüsselung kann nicht gesalzen werden, da die verschlüsselten Werte müssen neu generiert werden", Das ist, warum es Häufig zu speichern, das Salz zusammen mit dem Hash-Passwort. Dieser Weg, wenn zwei verschiedene Benutzer das gleiche Kennwort haben, es produziert verschiedene hashes, aber für einen einzelnen Benutzer das gleiche Passwort immer den gleichen hash.
um ehrlich zu sein, ohne Salz ist es wirklich nicht verschlüsselt ist überhaupt. Sollte es nicht möglich sein, eine direkte Datenbank-lookup gegen einen verschlüsselten Wert.

InformationsquelleAutor bhs | 2013-06-19

aes c#encryption-symmetric hash

15

Können Sie konstruieren die Rfc2898DeriveBytes Class mit einer beliebigen Größe Kennwort und dann daraus einen Schlüssel der von Ihnen gewünschten Größe, in diesem Fall 256 bits (32 bytes):
```
private static byte[] CreateKey(string password, int keyBytes = 32)
{
    const int Iterations = 300;
    var keyGenerator = new Rfc2898DeriveBytes(password, Salt, Iterations);
    return keyGenerator.GetBytes(keyBytes);
}
```
Werden, um zu einem deterministischen output (d.h. gleicher Eingabe die gleiche Ausgabe erzeugen), müssen Sie die hard-code, das Salz. Das Salz muss mindestens 8 Byte:
```
private static readonly byte[] Salt = 
    new byte[] { 10, 20, 30 , 40, 50, 60, 70, 80};
```
Finden Sie meine Erklärung für eine theoretische Beschreibung von oben. Beachten Sie, dass Rfc2898DeriveBytes implementiert PBKDF2 🙂
Danke - das war sehr hilfreich. Sollte keySize 32 wenn man ein 32-byte-Schlüssel-array ?
Ja, ich denke, das war ein bisschen ein Fehler von ByteBlast. Ich würde auch Ratschläge für die Codierung des Passwortes in bytes mit UTF-8-Codierung, da die Rfc2898DeriveBytes-Funktion nicht explizit die Kodierung, die es verwendet. Das ist schwierig, wenn man die Funktion aus einer anderen Laufzeit.

InformationsquelleAutor User 12345678
2

Wahrscheinlich der beste Weg ist die Verwendung von PBKDF2 mit SHA256 (welche generiert 256-bit-Ausgabe) und einen für die Anwendung spezifischen Salz - & iteration-count. Sie sollten sich bewusst sein, dass eine Anwendung bestimmte Salz entfernt eine ganze Menge Schutz von PBKDF2, so benötigen Sie möglicherweise einen zusätzlichen Schutz um dieses Problem zu lindern. Eine Methode wäre, um sicherzustellen, dass die Datenbank sicher ist, und dass eine maximale Anzahl von versuchen verwendet werden können.

Sind Sie richtig, die besagt, dass ein 32 char-passphrase ist nicht einer 256-bit-Schlüssel. Es enthält nicht genug Entropie, und einige bytes können nicht einmal gültige Charakter-Darstellungen.

Sehen ByteBlasts Antwort für eine Implementierung von oben 🙂
Vielen Dank - so ein 32-byte-array aus der Methode oben ist mit einer 256-bit-Schlüssel ?
Es ist ein password based key derivation function, das ist, was PBKDF bedeutet. Setzen Sie ein Passwort, erhalten Sie einen Schlüssel zurück (als bytes). Es hat Schutz über eine Salz-und eine Anzahl von Iterationen, die macht es relativ schwer zu berechnen, den Schlüssel (für Sie und ein Angreifer). Ein Angreifer muss wahrscheinlich eine Menge tun, um von Ihnen zu bekommen, um die Schlüssel zu. Allerdings ist es am besten zu verwenden SHA-256 oder höher, weil es erfordert, um die volle Anzahl der Iterationen für alles, was über eine hash-Ausgabe - und dies ist wahrscheinlich nur Fehler, die Sie, nicht der Angreifer.

InformationsquelleAutor Maarten Bodewes

public static string GenerateBitKey(int letterCount = 44)
    {
        //Get the number of words and letters per word.
        int num_letters = letterCount;
        //Make an array of the letters we will use.
        char[] letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".ToCharArray();

        //Make a random number generator.
        Random rand = new Random();

        //Make the words.
        //Make a word.
        string word = "";
        for (int j = 1; j <= num_letters; j++)
        {
            //Pick a random number between 0 and 25
            //to select a letter from the letters array.
            int letter_num = rand.Next(0, letters.Length - 1);

            //Append the letter.
            word += letters[letter_num];
        }
        return word;
    }

Das sieht mehr wie der code zum erzeugen einer zufälligen - Taste, nicht zu verwandeln, eine passphrase-Zeichenfolge wiederholbar in einem abgeleiteten Schlüssel.
Zu Schlüssel generieren von Passwort-siehe meine Antwort unten

InformationsquelleAutor Minute V

 private static IBuffer GetMD5Hash(string key)
    {
        IBuffer bufferUTF8Msg = CryptographicBuffer.ConvertStringToBinary(key, BinaryStringEncoding.Utf8);
        HashAlgorithmProvider hashAlgorithmProvider = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
        IBuffer hashBuffer = hashAlgorithmProvider.HashData(bufferUTF8Msg);
        if (hashBuffer.Length != hashAlgorithmProvider.HashLength)
        {
            throw new Exception("There was an error creating the hash");
        }
        return hashBuffer;
    }

    #region Static

    public static string GenerateKey(string password, int resultKeyLength = 68)
    {
        if (password.Length < 6)
            throw new ArgumentException("password length must atleast 6 characters or above");
        string key = "";

        var hashKey = GetMD5Hash(password);
        var decryptBuffer = CryptographicBuffer.ConvertStringToBinary(password, BinaryStringEncoding.Utf8);
        var AES = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
        var symmetricKey = AES.CreateSymmetricKey(hashKey);
        var encryptedBuffer = CryptographicEngine.Encrypt(symmetricKey, decryptBuffer, null);
        key = CryptographicBuffer.EncodeToBase64String(encryptedBuffer);
        string cleanKey  = key.Trim(new char[] { ' ', '\r', '\t', '\n', '/', '+', '=' });
        cleanKey = cleanKey.Replace("/", string.Empty).Replace("+", string.Empty).Replace("=", string.Empty);
        key = cleanKey;
        if(key.Length > resultKeyLength)
        {
           key = key.Substring(0, Math.Min(key.Length, resultKeyLength));
        }
        else if(key.Length == resultKeyLength)
        {
            return key;
        }
        else if (key.Length < resultKeyLength)
        {
            key = GenerateKey(key);
        }
        return key;

    }

//Hole den ersten 44 Zeichen für die AES-Schlüssel und die restlichen chars für AES IV

InformationsquelleAutor Minute V

-1

Können Sie einige hash-Funktion, die bietet 256-bit-outuput aus einer Eingabe mit beliebiger Länge, z.B. SHA256.

Offiziell ein hash ist kein Password Based Key Derivation Function, und sollte nicht direkt als solche verwendet werden.

InformationsquelleAutor alex

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.