Заполнение недействительно и не может быть удалено?

Я поискал в Интернете, что означает это исключение по отношению к моей программе, но не могу найти решения или причины, по которой это происходит с моей конкретной программой. Я использовал пример, предоставленный моим msdn, для шифрования и дешифрования XmlDocument с использованием алгоритма Rijndael. Шифрование работает нормально, но когда я пытаюсь расшифровать, я получаю следующее исключение:

Заполнение недействительно и не может быть удалено

Может ли кто-нибудь сказать мне, что я могу сделать, чтобы решить эту проблему? В приведенном ниже коде я получаю ключ и другие данные. Если cryptoMode имеет значение false, он вызовет метод дешифрования, в котором возникает исключение:

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 - это блочный шифр. Он шифрует данные блоками по 128 бит (16 символов). Криптографическое заполнение используется, чтобы гарантировать, что последний блок сообщения всегда имеет правильный размер.

Ваш метод дешифрования ожидает заполнения по умолчанию и не находит его. Как говорит @NetSquirrel, вам необходимо явно установить заполнение как для шифрования, так и для дешифрования. Если у вас нет причин поступить иначе, используйте заполнение PKCS # 7.

Убедитесь, что ключи, которые вы используете для шифрования и дешифрования , одинаковы . Метод заполнения, даже если он не установлен явно, должен по-прежнему обеспечивать правильное дешифрование / шифрование (если не задано, они будут такими же). Однако , если вы по какой - то причине используют другой набор ключей для расшифровки , чем используемый для шифрования вы будете получать эту ошибку:

Заполнение недействительно и не может быть удалено

Если вы используете какой-либо алгоритм для динамической генерации ключей, это не сработает. Они должны быть одинаковыми как для шифрования, так и для дешифрования. Один из распространенных способов состоит в том, чтобы вызывающий объект предоставил ключи в конструкторе класса методов шифрования, чтобы предотвратить участие процесса шифрования / дешифрования в создании этих элементов. Он сосредоточен на задаче (шифрование и дешифрование данных) и требует ivи keyдолжны быть предоставлена вызывающим.

В интересах поиска людей, возможно, стоит проверить расшифровку входных данных. В моем случае информация, отправляемая для дешифрования, была (ошибочно) введена как пустая строка. Это привело к ошибке заполнения.

Это может относиться к ответу Россума, но подумал, что стоит упомянуть.

Если один и тот же ключ и вектор инициализации используются для кодирования и декодирования, эта проблема возникает не из-за декодирования данных, а из-за кодирования данных.

После того, как вы вызвали метод Write для объекта CryptoStream, вы должны ВСЕГДА вызывать метод FlushFinalBlock перед методом Close.

В документации MSDN по методу CryptoStream.FlushFinalBlock говорится:
« Вызов метода Close вызовет FlushFinalBlock ... »
https://msdn.microsoft.com/en-US/library/system.security.cryptography.cryptostream.flushfinalblock(v=vs .110) .aspx
Это неверно. Вызов метода Close просто закрывает CryptoStream и выходной поток.
Если вы не вызываете FlushFinalBlock перед Close после того, как вы записали данные для шифрования, при расшифровке данных вызов метода Read или CopyTo в вашем объекте CryptoStream вызовет исключение CryptographicException (сообщение: «Заполнение недопустимо и не может быть удалено»).

Это, вероятно, верно для всех алгоритмов шифрования, производных от SymmetricAlgorithm (Aes, DES, RC2, Rijndael, TripleDES), хотя я только что проверил это для AesManaged и MemoryStream в качестве выходного потока.

Итак, если вы получаете это исключение CryptographicException при расшифровке, прочтите значение свойства Output Stream Length после того, как вы записали данные для шифрования, затем вызовите FlushFinalBlock и снова прочитайте его значение. Если он изменился, вы знаете, что вызов FlushFinalBlock НЕ является необязательным.

И вам не нужно выполнять какие-либо дополнения программно или выбирать другое значение свойства Padding. Заполнение - это задание метода FlushFinalBlock.

.........

Дополнительное замечание для Кевина:

Да, CryptoStream вызывает FlushFinalBlock перед вызовом Close, но уже слишком поздно: когда вызывается метод CryptoStream Close, выходной поток также закрывается.

Если ваш выходной поток является MemoryStream, вы не можете прочитать его данные после его закрытия. Таким образом, вам нужно вызвать FlushFinalBlock в своем CryptoStream перед использованием зашифрованных данных, записанных в MemoryStream.

Если ваш выходной поток - FileStream, дела обстоят хуже, потому что запись буферизуется. В результате последние записанные байты могут не быть записаны в файл, если вы закроете выходной поток перед вызовом Flush для FileStream. Поэтому перед вызовом Close в CryptoStream вам сначала нужно вызвать FlushFinalBlock в своем CryptoStream, а затем вызвать Flush в своем FileStream.

Сервал времен боев, я наконец решил проблему.
(Примечание: в качестве симметричного алгоритма я использую стандартный AES. Этот ответ может подойти не всем.)

1. Измените класс алгоритма. Замени RijndaelManagedкласс на AESManagedодин.
2. Не указывать явно KeySizeкласс алгоритма, оставил их по умолчанию.
   (Это очень важный шаг. Я думаю, что в свойстве KeySize есть ошибка.)

Вот список, который вы хотите проверить, какой аргумент вы могли пропустить:

• Ключ
  (байтовый массив, длина должна быть ровно одной из 16, 24, 32 байтов для разного размера ключа.)
• IV
  (байтовый массив, 16 байт)
• CipherMode
  (один из CBC, CFB, CTS, ECB, OFB)
• PaddingMode
  (один из ANSIX923, ISO10126, None, PKCS7, Zeros)

Моя проблема заключалась в том, что passPhrase для шифрования не соответствовал passPhrase для дешифрования ... поэтому он выдал эту ошибку ... немного вводит в заблуждение.

Решение, исправившее мое, заключалось в том, что я случайно применил разные ключи к методам шифрования и дешифрования.

Я столкнулся с этой ошибкой при попытке передать незашифрованный путь к файлу методу Decrypt. Решение заключалось в том, чтобы сначала проверить, зашифрован ли переданный файл, прежде чем пытаться расшифровать.

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

Другой сценарий, опять же в интересах поиска людей.

Для меня эта ошибка возникла во время метода Dispose (), который замаскировал предыдущую ошибку, не связанную с шифрованием.

После исправления другого компонента это исключение исчезло.

Я столкнулся с этой ошибкой заполнения, когда вручную редактировал зашифрованные строки в файле (используя блокнот), потому что хотел проверить, как будет вести себя функция дешифрования, если мой зашифрованный контент был изменен вручную.

Решением для меня было разместить

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

Как я уже сказал, моя ошибка заполнения была связана с тем, что я вручную набирал расшифрованный текст с помощью блокнота. Может быть, мой ответ поможет вам найти решение.

У меня была такая же ошибка. В моем случае это произошло потому, что я сохранил зашифрованные данные в базе данных SQL. Таблица, в которой хранятся данные, имеет двоичный (1000) тип данных. При получении данных из базы данных он расшифровывает эти 1000 байтов, тогда как на самом деле там было 400 байтов. Таким образом, удаление конечных нулей (600) из результата решило проблему.

У меня была эта ошибка, и я явно устанавливал размер блока: aesManaged.BlockSize = 128;

Как только я удалил это, все заработало.

У меня была такая же проблема при переносе программы Go на C #. Это означает, что с помощью программы Go уже было зашифровано много данных. Теперь эти данные необходимо расшифровать с помощью C #.

Окончательное решение было PaddingMode.Noneточнее PaddingMode.Zeros.

Криптографические методы в 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
}

... и ...

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

Теперь расшифровка на 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;
}

Как можно объяснить проблему с заполнением? Непосредственно перед шифрованием программа Go проверяет заполнение:

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

Важная часть заключается в следующем:

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

Создается новый массив соответствующей длины, так что длина кратна размеру блока. Этот новый массив заполнен нулями. Затем метод копирования копирует в него существующие данные. Гарантируется, что новый массив больше существующих данных. Соответственно в конце массива стоят нули.

Таким образом, код C # может использовать PaddingMode.Zeros. Альтернатива PaddingMode.Noneпросто игнорирует любые отступы, что также работает. Надеюсь, этот ответ будет полезен всем, кому нужно переносить код с Go на C # и т. Д.

Клиент сообщил мне об этой же ошибке. Я лично не могу это воспроизвести. Если посмотреть на код методов Encrypt и Decrypt , у обоих Padding установлено значение PaddingMode.PKCS7 . Расшифровка выглядит так, и я не вижу в ней проблемы с « FlushFinalBlock ». Может кто-нибудь пролить свет на это?

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", "");
}

У меня была такая же ошибка. В моем случае данный пароль больше 16 означает, что он зашифрован, но при расшифровке я получаю эту ошибку. Шифрование:

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;

                    }
                }

Дешифрирование:

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