Encryption AES 256错误意味着填充无效且无法删除，这意味着什么？

首先，我看到了一些关于填充无效且无法删除的问题。我看了他们所有人，我的问题是安静的不同

我正在使用下面的代码，我可以从PS脚本中加密数据，并从.NET应用程序中解密

然而，当我尝试在.NET/PS脚本上加密文本并尝试在下面的站点上解密时，它不起作用

当我尝试使用相同的密钥将此站点上的加密数据解密为PS或.NET代码时，我不断收到以下错误： 填充无效，无法删除

我使用了256位的密钥，密钥是完全相同的

/// <summary>
    /// AES wrapper implementation by Yovav Gad using the AesManaged algorithm.
    /// <para>http://en.wikipedia.org/wiki/Advanced_Encryption_Standard</para>
    /// </summary>
    public sealed class AesWrapper
    {
        /// <summary>
        /// Create a SymmetricAlgorithm using AesManaged
        /// </summary>
        /// <param name="key">Byte array representing the key values, please note, 
        /// for better performance, use Convert.FromBase64String() outside of this method.</param>
        /// <param name="blockSize">BlockSize, default is 128</param>
        /// <param name="paddingMode">PaddingMode, default is PaddingMode.PKCS7</param>
        /// <param name="cipherMode">CipherMode, default is CipherMode.CBC</param>
        /// <returns></returns>
        private static SymmetricAlgorithm CreateCrypto(
            byte[] key,
            int blockSize = 128,
            PaddingMode paddingMode = PaddingMode.PKCS7,
            CipherMode cipherMode = CipherMode.CBC
            )
        {
            SymmetricAlgorithm crypto = new AesManaged
            {
                Key = key,
                Mode = cipherMode,
                Padding = paddingMode,
                BlockSize = blockSize
            };

            crypto.IV = new byte[crypto.IV.Length];

            return (crypto);
        }

        /// <summary>
        /// Decrypt an encrypted string using a specific key.
        /// </summary>
        /// <param name="str">String to decrypt</param>
        /// <param name="key">Byte array representing the key values, please note, 
        /// for better performance, use Convert.FromBase64String() outside of this method.</param>
        /// <param name="blockSize">BlockSize, default is 128</param>
        /// <param name="paddingMode">PaddingMode, default is PaddingMode.Zeros</param>
        /// <param name="cipherMode">CipherMode, default is CipherMode.CBC</param>
        /// <returns></returns>
        [DebuggerStepThrough()]
        public static string Decrypt(
            string str,
            byte[] key,
            int blockSize = 128,
            PaddingMode paddingMode = PaddingMode.PKCS7,
            CipherMode cipherMode = CipherMode.CBC
            )
        {
            if (str == null || str.Length < 1 ||
                key == null || key.Length < 1)
            {
                return null;
            }

            var result = string.Empty;

            using (var crypto = CreateCrypto(key, blockSize, paddingMode, cipherMode))
            {
                var strCombined = Convert.FromBase64String(str);
                var iv = new byte[crypto.BlockSize / 8];
                var cipherText = new byte[strCombined.Length - iv.Length];
                Array.Copy(strCombined, iv, iv.Length);
                Array.Copy(strCombined, iv.Length, cipherText, 0, cipherText.Length);

                crypto.IV = iv;
                ICryptoTransform decryptor = crypto.CreateDecryptor(key, iv);

                using (var msDecrypt = new MemoryStream(cipherText))
                {
                    using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (var srDecrypt = new StreamReader(csDecrypt))
                        {
                            result = srDecrypt.ReadToEnd();
                        }
                    }
                }

                if (paddingMode == PaddingMode.PKCS7)
                {
                    // This is required when using PaddingMode.Zeros for values shorted than the block size.
                    // Note: using .TrimEnd('\0') to remove nulls and not .TrimEnd("\0") to allow the string values.
                    result = result.TrimEnd('\0');
                }

                return (result);
            }
        }

        /// <summary>
        /// Encrypt a string using a specific key.
        /// </summary>
        /// <param name="str">String to encrypt</param>
        /// <param name="key">Byte array representing the key values, please note, 
        /// for better performance, use Convert.FromBase64String() outside of this method.</param>
        /// <param name="blockSize">BlockSize, default is 128</param>
        /// <param name="paddingMode">PaddingMode, default is PaddingMode.Zeros</param>
        /// <param name="cipherMode">CipherMode, default is CipherMode.CBC</param>
        /// <returns></returns>
        [DebuggerStepThrough()]
        public static string Encrypt(
            string str,
            byte[] key,
            int blockSize = 128,
            PaddingMode paddingMode = PaddingMode.PKCS7,
            CipherMode cipherMode = CipherMode.CBC
            )
        {
            if (str == null || str.Length < 1 ||
                key == null || key.Length < 1)
            {
                return null;
            }

            byte[] encryptedData;

            using (SymmetricAlgorithm crypto = CreateCrypto(key, blockSize, paddingMode, cipherMode))
            {
                byte[] data;
                crypto.GenerateIV();
                var iv = crypto.IV;
                var encryptor = crypto.CreateEncryptor(key, iv);

                using (MemoryStream ms = new MemoryStream())
                {
                    using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter sw = new StreamWriter(cs))
                        {
                            sw.Write(str);
                        }

                        data = ms.ToArray();
                    }
                }

                // Combine the iv (salt) and the encrypted data
                encryptedData = new byte[iv.Length + data.Length];
                Array.Copy(iv, 0, encryptedData, 0, iv.Length);
                Array.Copy(data, 0, encryptedData, iv.Length, data.Length);
            }

            return Convert.ToBase64String(encryptedData);
        }
    }


void Main()
{
    var keyString = "8CBaNtMYwAuu2K/xleoRfgPkURaLK82QidlIyg+nFY4=";
    var keyBytes = Convert.FromBase64String(keyString); 
    var plainText = "aes test";
    
    var testEncrypted = AesWrapper.Encrypt(plainText, keyBytes);
    Console.WriteLine(testEncrypted);
    var testDecrypted = AesWrapper.Decrypt("gM+oae1MZlj42b9UtCw2dw==", keyBytes);
    Console.WriteLine(testDecrypted);
    var testReEncrypted = AesWrapper.Encrypt(testEncrypted, keyBytes);
}

PS脚本

    function Create-AesManagedObject($key, $IV) {
    $aesManaged = New-Object "System.Security.Cryptography.AesManaged"
    $aesManaged.Mode = [System.Security.Cryptography.CipherMode]::CBC
    $aesManaged.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7
    $aesManaged.BlockSize = 128
    $aesManaged.KeySize = 256
    if ($IV) {
        if ($IV.getType().Name -eq "String") {
            $aesManaged.IV = [System.Convert]::FromBase64String($IV)
        }
        else {
            $aesManaged.IV = $IV
        }
    }
    if ($key) {
        if ($key.getType().Name -eq "String") {
            $aesManaged.Key = [System.Convert]::FromBase64String($key)
        }
        else {
            $aesManaged.Key = $key
        }
    }
    $aesManaged
}

function Create-AesKey() {
    $aesManaged = Create-AesManagedObject
    $aesManaged.GenerateKey()
    [System.Convert]::ToBase64String($aesManaged.Key)
}

function Encrypt-String($key, $unencryptedString) {
    $bytes = [System.Text.Encoding]::UTF8.GetBytes($unencryptedString)
    $aesManaged = Create-AesManagedObject $key
    $encryptor = $aesManaged.CreateEncryptor()
    $encryptedData = $encryptor.TransformFinalBlock($bytes, 0, $bytes.Length);
    [byte[]] $fullData = $aesManaged.IV + $encryptedData
    $aesManaged.Dispose()
    [System.Convert]::ToBase64String($fullData)
}

function Decrypt-String($key, $encryptedStringWithIV) {
    $bytes = [System.Convert]::FromBase64String($encryptedStringWithIV)
    $IV = $bytes[0..15]
    $aesManaged = Create-AesManagedObject $key $IV
    $decryptor = $aesManaged.CreateDecryptor();
    $unencryptedData = $decryptor.TransformFinalBlock($bytes, 16, $bytes.Length - 16);
    $aesManaged.Dispose()
    [System.Text.Encoding]::UTF8.GetString($unencryptedData).Trim([char]0)
}


cls

<#
# This will generate a new valid AES 256 key if needed:
# $key = Create-AesKey
#>

<# 
# This is the hard coded key
#>
$key = Create-AesKey
#$key = "8CBaNtMYwAuu2K/xleoRfgPkURaLK82Q"
Write-Host "key = $key"

$unencryptedString = "dil pun"
Write-Host "unencryptedString = $unencryptedString"

$encryptedString = Encrypt-String $key $unencryptedString
Write-Host "encryptedString  = $encryptedString "

$backToPlainText = Decrypt-String $key $encryptedString
Write-Host "backToPlainText = $backToPlainText"


<#
# To run this PowerShell script:
#
# In Windows PowerShell:
# .\PowerShell_AES_Encryption_Example.ps1
# C:\Test\PowerShell_AES_Encryption_Example.ps1
# 
# In Command Prompt:
# powershell -noexit "& ""C:\Test\PowerShell_AES_Encryption_Example.ps1"""
#>

你知道为什么这段代码不能解密使用相同密钥加密的数据，反之亦然吗

双方到底需要匹配什么？例如键大小、键值、填充和模式

IV、基础etc是否需要匹配

谢谢

双方到底需要匹配什么

对于AES，您必须使用完全相同的值进行加密和解密：

键将其打印为十六进制键并进行比较 IV 16字节的随机数据用于加密，解密使用与加密相同的字节。常见的方法是在加密数据前添加IV，并在执行实际解密之前读取它。 加密模式 衬料

---

所有这些工作都是为了编写一个问题，两个代码段中的填充模式都明显不同。在一个代码中，我看到了PaddingMode.zero，而在另一个代码中，PaddingMode设置为从不使用零。您需要使用完全相同的填充算法进行解密和加密！是的，已经尝试使用两种相同的填充物，即PKS7。还是不行