Polsterung ist ungültig und kann nicht entfernt werden?

Ich habe online gesucht, was diese Ausnahme in Bezug auf mein Programm bedeutet, kann aber anscheinend keine Lösung finden oder den Grund, warum es mit meinem spezifischen Programm passiert. Ich habe das Beispiel meiner msdn zum Ver- und Entschlüsseln eines XmlDocument mit dem Rijndael-Algorithmus verwendet. Die Verschlüsselung funktioniert einwandfrei, aber wenn ich versuche zu entschlüsseln, erhalte ich die folgende Ausnahme:

Das Auffüllen ist ungültig und kann nicht entfernt werden

Kann mir jemand sagen, was ich tun kann, um dieses Problem zu lösen? In meinem Code unten erhalte ich den Schlüssel und andere Daten. Wenn der cryptoMode false ist, wird die Entschlüsselungsmethode aufgerufen, bei der die Ausnahme auftritt:

public void Cryptography(XmlDocument doc, bool cryptographyMode)
{
    RijndaelManaged key = null;
    try
    {
    // Create a new Rijndael key.
    key = new RijndaelManaged();
    const string passwordBytes = "Password1234"; //password here 

    byte[] saltBytes = Encoding.UTF8.GetBytes("SaltBytes");
    Rfc2898DeriveBytes p = new Rfc2898DeriveBytes(passwordBytes, saltBytes);
    // sizes are devided by 8 because [ 1 byte = 8 bits ] 
    key.IV = p.GetBytes(key.BlockSize/8);
    key.Key = p.GetBytes(key.KeySize/8);

    if (cryptographyMode)
    {
        Ecrypt(doc, "Content", key);
    }
    else
    {
        Decrypt(doc, key);
    }

    }
    catch (Exception ex)
    {
    MessageBox.Show(ex.Message);
    }
    finally
    {
    // Clear the key.
    if (key != null)
    {
        key.Clear();
    }
    }

}

private void Decrypt(XmlDocument doc, SymmetricAlgorithm alg)
{
    // Check the arguments.  
    if (doc == null)
    throw new ArgumentNullException("Doc");
    if (alg == null)
    throw new ArgumentNullException("alg");

    // Find the EncryptedData element in the XmlDocument.
    XmlElement encryptedElement = doc.GetElementsByTagName("EncryptedData")[0] as XmlElement;

    // If the EncryptedData element was not found, throw an exception.
    if (encryptedElement == null)
    {
    throw new XmlException("The EncryptedData element was not found.");
    }


    // Create an EncryptedData object and populate it.
    EncryptedData edElement = new EncryptedData();
    edElement.LoadXml(encryptedElement);

    // Create a new EncryptedXml object.
    EncryptedXml exml = new EncryptedXml();


    // Decrypt the element using the symmetric key.
    byte[] rgbOutput = exml.DecryptData(edElement, alg); <----  I GET THE EXCEPTION HERE
    // Replace the encryptedData element with the plaintext XML element.
    exml.ReplaceData(encryptedElement, rgbOutput);

}

Rijndael / AES ist eine Blockverschlüsselung. Es verschlüsselt Daten in 128-Bit-Blöcken (16 Zeichen). Durch kryptografisches Auffüllen wird sichergestellt, dass der letzte Block der Nachricht immer die richtige Größe hat.

Ihre Entschlüsselungsmethode erwartet, was auch immer die Standardauffüllung ist, und findet sie nicht. Wie @NetSquirrel sagt, müssen Sie die Auffüllung sowohl für die Verschlüsselung als auch für die Entschlüsselung explizit festlegen. Verwenden Sie PKCS # 7-Polsterung, sofern Sie keinen Grund haben, etwas anderes zu tun.

Stellen Sie sicher , dass die Schlüssel Sie verwenden verschlüsseln und entschlüsseln sind die gleichen . Die Auffüllmethode sollte auch dann, wenn sie nicht explizit festgelegt wurde, eine ordnungsgemäße Entschlüsselung / Verschlüsselung ermöglichen (wenn sie nicht festgelegt ist, sind sie gleich). Wenn Sie jedoch aus irgendeinem Grund einen anderen Schlüsselsatz zur Entschlüsselung verwenden als zur Verschlüsselung, wird folgende Fehlermeldung angezeigt:

Das Auffüllen ist ungültig und kann nicht entfernt werden

Wenn Sie einen Algorithmus verwenden, um dynamisch Schlüssel zu generieren, die nicht funktionieren. Sie müssen für die Ver- und Entschlüsselung gleich sein. Eine übliche Methode besteht darin, dass der Aufrufer die Schlüssel im Konstruktor der Klasse der Verschlüsselungsmethoden bereitstellt, um zu verhindern, dass der Verschlüsselungs- / Entschlüsselungsprozess bei der Erstellung dieser Elemente eine Rolle spielt. Es konzentriert sich auf die jeweilige Aufgabe (Ver- und Entschlüsseln von Daten) und erfordert, dass das ivund keyvom Anrufer bereitgestellt wird.

Für die Suche kann es sich lohnen, die entschlüsselte Eingabe zu überprüfen. In meinem Fall wurden die zur Entschlüsselung gesendeten Informationen (fälschlicherweise) als leere Zeichenfolge eingegeben. Dies führte zu einem Auffüllfehler.

Dies mag sich auf Rossums Antwort beziehen, hielt es aber für erwähnenswert.

Wenn für die Codierung und Decodierung derselbe Schlüssel und der gleiche Initialisierungsvektor verwendet werden, liegt dieses Problem nicht bei der Datendecodierung, sondern bei der Datencodierung.

Nachdem Sie die Write-Methode für ein CryptoStream-Objekt aufgerufen haben, müssen Sie IMMER die FlushFinalBlock-Methode vor der Close-Methode aufrufen.

In der MSDN-Dokumentation zur CryptoStream.FlushFinalBlock-Methode heißt es:
"Durch Aufrufen der Close-Methode wird FlushFinalBlock aufgerufen ... "
https://msdn.microsoft.com/de-DE/library/system.security.cryptography.cryptostream.flushfinalblock(v=vs .110) .aspx
Das ist falsch. Durch Aufrufen der Close-Methode werden nur der CryptoStream und der Ausgabestream geschlossen.
Wenn Sie FlushFinalBlock nicht vor dem Schließen aufrufen, nachdem Sie zu verschlüsselnde Daten geschrieben haben, löst ein Aufruf der Read- oder CopyTo-Methode für Ihr CryptoStream-Objekt beim Aufschlüsseln eine CryptographicException-Ausnahme aus (Meldung: "Auffüllen ist ungültig und kann nicht entfernt werden").

Dies gilt wahrscheinlich für alle von SymmetricAlgorithm abgeleiteten Verschlüsselungsalgorithmen (Aes, DES, RC2, Rijndael, TripleDES), obwohl ich dies gerade für AesManaged und einen MemoryStream als Ausgabestream überprüft habe.

Wenn Sie diese CryptographicException-Ausnahme bei der Entschlüsselung erhalten, lesen Sie den Wert Ihrer Ausgabestream-Length-Eigenschaft, nachdem Sie Ihre zu verschlüsselnden Daten geschrieben haben. Rufen Sie dann FlushFinalBlock auf und lesen Sie den Wert erneut. Wenn es sich geändert hat, wissen Sie, dass das Aufrufen von FlushFinalBlock NICHT optional ist.

Außerdem müssen Sie kein Auffüllen programmgesteuert durchführen oder einen anderen Wert für die Padding-Eigenschaft auswählen. Das Auffüllen ist ein FlushFinalBlock-Methodenjob.

.........

Zusätzliche Bemerkung für Kevin:

Ja, CryptoStream ruft FlushFinalBlock auf, bevor Close geschlossen wird, aber es ist zu spät: Wenn die CryptoStream Close-Methode aufgerufen wird, wird auch der Ausgabestream geschlossen.

Wenn Ihr Ausgabestream ein MemoryStream ist, können Sie seine Daten nach dem Schließen nicht mehr lesen. Sie müssen also FlushFinalBlock in Ihrem CryptoStream aufrufen, bevor Sie die im MemoryStream geschriebenen verschlüsselten Daten verwenden können.

Wenn Ihr Ausgabestream ein FileStream ist, sind die Dinge schlechter, weil das Schreiben gepuffert ist. Die Folge ist, dass zuletzt geschriebene Bytes möglicherweise nicht in die Datei geschrieben werden, wenn Sie den Ausgabestream schließen, bevor Sie Flush in FileStream aufrufen. Bevor Sie Close in CryptoStream aufrufen, müssen Sie zuerst FlushFinalBlock in Ihrem CryptoStream aufrufen und dann Flush in Ihrem FileStream aufrufen.

Nach mehreren Kämpfen löste ich endlich das Problem.
(Hinweis: Ich verwende Standard-AES als symmetrischen Algorithmus. Diese Antwort ist möglicherweise nicht für alle geeignet.)

1. Ändern Sie die Algorithmusklasse. Ersetzen Sie die RijndaelManagedKlasse durch AESManagedeine.
2. Legen Sie die KeySizeAlgorithmusklasse nicht explizit fest, sondern belassen Sie sie als Standard.
   (Dies ist der sehr wichtige Schritt. Ich denke, es gibt einen Fehler in der KeySize-Eigenschaft.)

Hier ist eine Liste, in der Sie überprüfen möchten, welches Argument Sie möglicherweise übersehen haben:

• Schlüssel
  (Byte-Array, Länge muss für unterschiedliche Schlüsselgrößen genau 16, 24, 32 Byte betragen.)
• IV
  (Byte-Array, 16 Byte)
• CipherMode
  (einer von CBC, CFB, CTS, EZB, OFB)
• PaddingMode
  (Einer von ANSIX923, ISO10126, None, PKCS7, Zeros)

Mein Problem war, dass die passPhrase der Verschlüsselung nicht mit der passPhrase der Entschlüsselung übereinstimmte ... also warf es diesen Fehler ... ein wenig irreführend.

Die Lösung, die meine behoben hat, war, dass ich versehentlich verschiedene Schlüssel auf Verschlüsselungs- und Entschlüsselungsmethoden angewendet hatte.

Ich bin auf diesen Fehler gestoßen, als ich versucht habe, einen unverschlüsselten Dateipfad an die Entschlüsselungsmethode zu übergeben. Die Lösung bestand darin, zu überprüfen, ob die übergebene Datei zuerst verschlüsselt ist, bevor versucht wird, sie zu entschlüsseln

if (Sec.IsFileEncrypted(e.File.FullName))
{
    var stream = Sec.Decrypt(e.File.FullName);
} 
else
{
    // non-encrypted scenario  
}

Ein weiteres Szenario, wiederum zum Nutzen der Suchenden.

Für mich trat dieser Fehler während der Dispose () -Methode auf, die einen früheren Fehler maskierte, der nicht mit der Verschlüsselung zusammenhängt.

Sobald die andere Komponente behoben war, verschwand diese Ausnahme.

Ich habe diesen Auffüllfehler festgestellt, als ich die verschlüsselten Zeichenfolgen in der Datei manuell bearbeitet habe (mit dem Editor), weil ich testen wollte, wie sich die Entschlüsselungsfunktion verhält, wenn mein verschlüsselter Inhalt manuell geändert wird.

Die Lösung für mich war, eine zu platzieren

        try
            decryption stuff....
        catch
             inform decryption will not be carried out.
        end try

Wie ich bereits sagte, war mein Auffüllfehler darauf zurückzuführen, dass ich den entschlüsselten Text manuell mit dem Editor eingegeben habe. Vielleicht führt Sie meine Antwort zu Ihrer Lösung.

Ich hatte den gleichen Fehler. In meinem Fall lag es daran, dass ich die verschlüsselten Daten in einer SQL-Datenbank gespeichert habe. Die Tabelle, in der die Daten gespeichert sind, hat einen binären Datentyp (1000). Beim Abrufen der Daten aus der Datenbank werden diese 1000 Bytes entschlüsselt, während dort tatsächlich 400 Bytes vorhanden sind. Durch Entfernen der nachgestellten Nullen (600) aus dem Ergebnis wurde das Problem behoben.

Ich hatte diesen Fehler und stellte explizit die Blockgröße ein: aesManaged.BlockSize = 128;

Sobald ich das entfernt habe, hat es funktioniert.

Ich hatte das gleiche Problem beim Versuch, ein Go-Programm nach C # zu portieren. Dies bedeutet, dass viele Daten bereits mit dem Go-Programm verschlüsselt wurden. Diese Daten müssen jetzt mit C # entschlüsselt werden.

Die endgültige Lösung war PaddingMode.Noneoder eher PaddingMode.Zeros.

Die kryptografischen Methoden in Go:

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/sha1"
    "encoding/base64"
    "io/ioutil"
    "log"

    "golang.org/x/crypto/pbkdf2"
)

func decryptFile(filename string, saltBytes []byte, masterPassword []byte) (artifact string) {

    const (
        keyLength         int = 256
        rfc2898Iterations int = 6
    )

    var (
        encryptedBytesBase64 []byte // The encrypted bytes as base64 chars
        encryptedBytes       []byte // The encrypted bytes
    )

    // Load an encrypted file:
    if bytes, bytesErr := ioutil.ReadFile(filename); bytesErr != nil {
        log.Printf("[%s] There was an error while reading the encrypted file: %s\n", filename, bytesErr.Error())
        return
    } else {
        encryptedBytesBase64 = bytes
    }

    // Decode base64:
    decodedBytes := make([]byte, len(encryptedBytesBase64))
    if countDecoded, decodedErr := base64.StdEncoding.Decode(decodedBytes, encryptedBytesBase64); decodedErr != nil {
        log.Printf("[%s] An error occur while decoding base64 data: %s\n", filename, decodedErr.Error())
        return
    } else {
        encryptedBytes = decodedBytes[:countDecoded]
    }

    // Derive key and vector out of the master password and the salt cf. RFC 2898:
    keyVectorData := pbkdf2.Key(masterPassword, saltBytes, rfc2898Iterations, (keyLength/8)+aes.BlockSize, sha1.New)
    keyBytes := keyVectorData[:keyLength/8]
    vectorBytes := keyVectorData[keyLength/8:]

    // Create an AES cipher:
    if aesBlockDecrypter, aesErr := aes.NewCipher(keyBytes); aesErr != nil {
        log.Printf("[%s] Was not possible to create new AES cipher: %s\n", filename, aesErr.Error())
        return
    } else {

        // CBC mode always works in whole blocks.
        if len(encryptedBytes)%aes.BlockSize != 0 {
            log.Printf("[%s] The encrypted data's length is not a multiple of the block size.\n", filename)
            return
        }

        // Reserve memory for decrypted data. By definition (cf. AES-CBC), it must be the same lenght as the encrypted data:
        decryptedData := make([]byte, len(encryptedBytes))

        // Create the decrypter:
        aesDecrypter := cipher.NewCBCDecrypter(aesBlockDecrypter, vectorBytes)

        // Decrypt the data:
        aesDecrypter.CryptBlocks(decryptedData, encryptedBytes)

        // Cast the decrypted data to string:
        artifact = string(decryptedData)
    }

    return
}

... und ...

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/sha1"
    "encoding/base64"
    "github.com/twinj/uuid"
    "golang.org/x/crypto/pbkdf2"
    "io/ioutil"
    "log"
    "math"
    "os"
)

func encryptFile(filename, artifact string, masterPassword []byte) (status bool) {

    const (
        keyLength         int = 256
        rfc2898Iterations int = 6
    )

    status = false
    secretBytesDecrypted := []byte(artifact)

    // Create new salt:
    saltBytes := uuid.NewV4().Bytes()

    // Derive key and vector out of the master password and the salt cf. RFC 2898:
    keyVectorData := pbkdf2.Key(masterPassword, saltBytes, rfc2898Iterations, (keyLength/8)+aes.BlockSize, sha1.New)
    keyBytes := keyVectorData[:keyLength/8]
    vectorBytes := keyVectorData[keyLength/8:]

    // Create an AES cipher:
    if aesBlockEncrypter, aesErr := aes.NewCipher(keyBytes); aesErr != nil {
        log.Printf("[%s] Was not possible to create new AES cipher: %s\n", filename, aesErr.Error())
        return
    } else {

        // CBC mode always works in whole blocks.
        if len(secretBytesDecrypted)%aes.BlockSize != 0 {
            numberNecessaryBlocks := int(math.Ceil(float64(len(secretBytesDecrypted)) / float64(aes.BlockSize)))
            enhanced := make([]byte, numberNecessaryBlocks*aes.BlockSize)
            copy(enhanced, secretBytesDecrypted)
            secretBytesDecrypted = enhanced
        }

        // Reserve memory for encrypted data. By definition (cf. AES-CBC), it must be the same lenght as the plaintext data:
        encryptedData := make([]byte, len(secretBytesDecrypted))

        // Create the encrypter:
        aesEncrypter := cipher.NewCBCEncrypter(aesBlockEncrypter, vectorBytes)

        // Encrypt the data:
        aesEncrypter.CryptBlocks(encryptedData, secretBytesDecrypted)

        // Encode base64:
        encodedBytes := make([]byte, base64.StdEncoding.EncodedLen(len(encryptedData)))
        base64.StdEncoding.Encode(encodedBytes, encryptedData)

        // Allocate memory for the final file's content:
        fileContent := make([]byte, len(saltBytes))
        copy(fileContent, saltBytes)
        fileContent = append(fileContent, 10)
        fileContent = append(fileContent, encodedBytes...)

        // Write the data into a new file. This ensures, that at least the old version is healthy in case that the
        // computer hangs while writing out the file. After a successfully write operation, the old file could be
        // deleted and the new one could be renamed.
        if writeErr := ioutil.WriteFile(filename+"-update.txt", fileContent, 0644); writeErr != nil {
            log.Printf("[%s] Was not able to write out the updated file: %s\n", filename, writeErr.Error())
            return
        } else {
            if renameErr := os.Rename(filename+"-update.txt", filename); renameErr != nil {
                log.Printf("[%s] Was not able to rename the updated file: %s\n", fileContent, renameErr.Error())
            } else {
                status = true
                return
            }
        }

        return
    }
}

Jetzt Entschlüsselung in C #:

public static string FromFile(string filename, byte[] saltBytes, string masterPassword)
{
    var iterations = 6;
    var keyLength = 256;
    var blockSize = 128;
    var result = string.Empty;
    var encryptedBytesBase64 = File.ReadAllBytes(filename);

    // bytes -> string:
    var encryptedBytesBase64String = System.Text.Encoding.UTF8.GetString(encryptedBytesBase64);

    // Decode base64:
    var encryptedBytes = Convert.FromBase64String(encryptedBytesBase64String);
    var keyVectorObj = new Rfc2898DeriveBytes(masterPassword, saltBytes.Length, iterations);
    keyVectorObj.Salt = saltBytes;
    Span<byte> keyVectorData = keyVectorObj.GetBytes(keyLength / 8 + blockSize / 8);
    var key = keyVectorData.Slice(0, keyLength / 8);
    var iv = keyVectorData.Slice(keyLength / 8);

    var aes = Aes.Create();
    aes.Padding = PaddingMode.Zeros;
    // or ... aes.Padding = PaddingMode.None;
    var decryptor = aes.CreateDecryptor(key.ToArray(), iv.ToArray());
    var decryptedString = string.Empty;

    using (var memoryStream = new MemoryStream(encryptedBytes))
    {
        using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
        {
            using (var reader = new StreamReader(cryptoStream))
            {
                decryptedString = reader.ReadToEnd();
            }
        }
    }

    return result;
}

Wie kann das Problem mit der Polsterung erklärt werden? Kurz vor der Verschlüsselung überprüft das Go-Programm die Auffüllung:

// CBC mode always works in whole blocks.
if len(secretBytesDecrypted)%aes.BlockSize != 0 {
    numberNecessaryBlocks := int(math.Ceil(float64(len(secretBytesDecrypted)) / float64(aes.BlockSize)))
    enhanced := make([]byte, numberNecessaryBlocks*aes.BlockSize)
    copy(enhanced, secretBytesDecrypted)
    secretBytesDecrypted = enhanced
}

Der wichtige Teil ist folgender:

enhanced := make([]byte, numberNecessaryBlocks*aes.BlockSize)
copy(enhanced, secretBytesDecrypted)

Ein neues Array mit einer geeigneten Länge wird erstellt, sodass die Länge ein Vielfaches der Blockgröße beträgt. Dieses neue Array ist mit Nullen gefüllt. Die Kopiermethode kopiert dann die vorhandenen Daten hinein. Es wird sichergestellt, dass das neue Array größer als die vorhandenen Daten ist. Dementsprechend befinden sich am Ende des Arrays Nullen.

Somit kann der C # -Code verwendet werden PaddingMode.Zeros. Die Alternative PaddingMode.Noneignoriert einfach jede Polsterung, die auch funktioniert. Ich hoffe, diese Antwort ist hilfreich für alle, die Code von Go to C # usw. portieren müssen.

Ich habe den gleichen Fehler vom Kunden gemeldet. Ich persönlich kann es nicht tadeln. Mit Blick auf den Code von Encrypt und Decrypt Methoden, beide haben Padding Satz PaddingMode.PKCS7 . Das Entschlüsseln sieht so aus und ich kann das Problem damit in Bezug auf ' FlushFinalBlock ' nicht erkennen. Könnte jemand bitte etwas Licht ins Dunkel bringen?

public string Decrypt(string cipherText)
{
  if (string.IsNullOrEmpty(cipherText))
    return "";
  string result;
  Encoding byteEncoder = Encoding.Default;

  byte[] rijnKey = byteEncoder.GetBytes(Password);
  byte[] rijnIv = byteEncoder.GetBytes(InitialVector);
  RijndaelManaged rijn = new RijndaelManaged { Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 };

  using (MemoryStream msDecrypt = new MemoryStream(Convert.FromBase64String(cipherText)))
  {
    using (ICryptoTransform decryptor = rijn.CreateDecryptor(rijnKey, rijnIv))
    {
      using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
      {
                    using (StreamReader swDecrypt = new StreamReader(csDecrypt))
                    {
                        result = swDecrypt.ReadToEnd();
                    }
                }
    }
  }
  rijn.Clear();      
  return result.Replace("\0", "");
}

Ich hatte den gleichen Fehler. In meinem Fall ist das angegebene Passwort größer als 16, was bedeutet, dass es verschlüsselt ist, aber während der Entschlüsselung erhalte ich diesen Fehler. Verschlüsselung:

string keyString = "CDFUYP@ssw0rd123";
            var key = Encoding.UTF8.GetBytes(keyString);            
            using (var aesAlg = Aes.Create())
            {
                using (var encryptor = aesAlg.CreateEncryptor(key, aesAlg.IV))
                {
                    using (var msEncrypt = new MemoryStream())
                    {
                        using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                        using (var swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(text);
                        }                          
                        var iv = aesAlg.IV;

                        var decryptedContent = msEncrypt.ToArray();

                        var result = new byte[iv.Length + decryptedContent.Length];

                        Buffer.BlockCopy(iv, 0, result, 0, iv.Length);
                        Buffer.BlockCopy(decryptedContent, 0, result, iv.Length, decryptedContent.Length);

                        var encryptedString = Convert.ToBase64String(result);
                        var decryptedString = Decrypt(encryptedString);
                        if (decryptedString == null)
                        {
                            return null;
                        }
                        return encryptedString;

                    }
                }

Entschlüsselung:

 string keyString = "CDFUYP@ssw0rd123";
            var fullCipher = Convert.FromBase64String(cipherText);
            var iv = new byte[16];
            var cipher = new byte[16];
            Buffer.BlockCopy(fullCipher, 0, iv, 0, iv.Length);
            Buffer.BlockCopy(fullCipher, iv.Length, cipher, 0, iv.Length);
            var key = Encoding.UTF8.GetBytes(keyString);

            using (var aesAlg = Aes.Create())
            {
                using (var decryptor = aesAlg.CreateDecryptor(key, iv))
                {
                    string result;
                    using (var msDecrypt = new MemoryStream(cipher))
                    {
                        using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                        {
                            using (var srDecrypt = new StreamReader(csDecrypt))
                            {
                                result = srDecrypt.ReadToEnd();
                            }
                        }
                    }

                    return result;
                }
            }