Criptografia não funciona usando C# System.Security.Cryptography

O modo CFB requer a especificação de um parâmetro adicional, a saber, o tamanho do segmento, que a MS chama de tamanho de feedback. O tamanho do segmento especifica o número de bits criptografados por etapa de criptografia, veja CFB . O tamanho do segmento é geralmente anexado, por exemplo, CFB-8 ou CFB-128 (CFB-128 às vezes também é chamado de CFB para abreviar).

O modo CFB não é implementado consistentemente nas várias versões do .NET. Algumas versões não o suportam de forma alguma e algumas o fazem de forma incompleta. Onde é suportado, não é implementado corretamente.

O .NET 8 (a versão .NET que você está usando) suporta CFB-128 (a variante CFB com a qual o texto cifrado HgnDCsJPaosJkvCF8jqPHUdSOVtCO2GeVQWiBCV9ocDRDM2EGUzNYRXyfoi gerado, veja CyberChef ). No entanto, a implementação .NET é falha: CFB é um modo de cifra de fluxo, de modo que nenhum preenchimento é necessário se implementado corretamente. Em contraste, a implementação MS requer preenchimento para um múltiplo do tamanho do segmento, que para CFB-128 corresponde a um bloco completo (16 bytes para AES). Consequentemente, o texto cifrado deve ser encurtado pelo número de bytes de preenchimento após a criptografia.
Como esse preenchimento é adicionado antes da criptografia e removido após a criptografia, o que significa que o número de bytes de preenchimento é conhecido, nenhum preenchimento PKCS#7 é necessário, em vez disso, um preenchimento simples como preenchimento zero é suficiente (em particular, não é necessário preencher um texto cifrado que já tenha o comprimento correto, como o preenchimento PKCS#7 faz).
Da mesma forma para descriptografia: o texto cifrado deve ser preenchido para o comprimento necessário, e os bytes de preenchimento devem ser removidos após a descriptografia.

Para fins de completude: o .NET 8 também suporta CFB-8, que é até o padrão. O tamanho do segmento para CFB-8 é de 8 bits, de modo que qualquer comprimento de texto simples pode ser criptografado sem preenchimento.

Criptografia/descriptografia CFB-128 com métodos nativos .NET:

private static byte[] AesEncrypt(byte[] key, byte[] iv, byte[] plaintext)
{
    byte[] ciphertext = null;
    using (Aes aesAlg = Aes.Create())
    {
        aesAlg.Key = key;
        ciphertext = aesAlg.EncryptCfb(plaintext, iv, PaddingMode.Zeros, 128); // pad
    }
    int padding = ciphertext.Length - plaintext.Length;
    return ciphertext[..^padding]; // remove padding
}

private static byte[] AesDecrypt(byte[] key, byte[] iv, byte[] ciphertext)
{
    int paddingSize = (16 - ciphertext.Length % 16) % 16;
    byte[] ciphertextPadded = ciphertext;
    if (paddingSize != 0)
    {
        ciphertextPadded = new byte[ciphertext.Length + paddingSize]; // pad
        Buffer.BlockCopy(ciphertext, 0, ciphertextPadded, 0, ciphertext.Length);
    }           
    byte[] decrypted = null;
    using (Aes aesAlg = Aes.Create())
    {
        aesAlg.Key = key;
        decrypted = aesAlg.DecryptCfb(ciphertextPadded, iv, PaddingMode.None, 128); 
    }
    return decrypted[..^paddingSize]; // remove padding
}

Com uma implementação CFB correta, o preenchimento/despreenchimento não é necessário. Para a implementação .NET, no entanto, um preenchimento/despreenchimento ausente resulta em exceções. Se você usar CFB-8 em vez de CFB-128, o preenchimento/despreenchimento pode ser omitido.

Para comparação, aqui está a solução com BouncyCastle:

private static byte[] AesEncrypt_BC(byte[] key, byte[] iv, byte[] plaintext)
{
    var cipher = CipherUtilities.GetCipher("AES/CFB");
    cipher.Init(true, new ParametersWithIV(new KeyParameter(key), iv));
    return cipher.DoFinal(plaintext);
}

private static byte[] AesDecrypt_BC(byte[] key, byte[] iv, byte[] ciphertext)
{
    var cipher = CipherUtilities.GetCipher("AES/CFB");
    cipher.Init(false, new ParametersWithIV(new KeyParameter(key), iv));
    return cipher.DoFinal(ciphertext);
}

Aqui, não é necessário preenchimento/despreenchimento, não importa quão longo seja o texto simples/cifrado, como deveria ser. Note que CFBsignifica CFB-128, enquanto CFB8se refere a CFB-8.

Uma solução com fluxos é:

private static byte[] AesEncrypt_streams(byte[] key, byte[] iv, byte[] plaintext)
{
    byte[] ciphertext = null;
    int padding = 0;
    using (Aes aesAlg = Aes.Create())
    {
        aesAlg.Padding = PaddingMode.Zeros; // must be specified, as PKCS#7 is the default // pad
        aesAlg.Mode = CipherMode.CFB; // must be specified, as CBC is the default
        aesAlg.FeedbackSize = 128; // must be specified, as CFB-8 is the default
        aesAlg.Key = key;
        aesAlg.IV = iv;
        ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
        using (MemoryStream msEncrypt = new MemoryStream())
        {
            using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
            {
                csEncrypt.Write(plaintext);
            }
            ciphertext = msEncrypt.ToArray();
        }
        padding = ciphertext.Length - plaintext.Length;
        return ciphertext[..^padding]; // remove padding
    }
}

private static byte[] AesDecrypt_streams(byte[] key, byte[] iv, byte[] ciphertext)
{
    int paddingSize = (16 - ciphertext.Length % 16) % 16;
    byte[] ciphertextPadded = ciphertext;
    if (paddingSize != 0)
    {
        ciphertextPadded = new byte[ciphertext.Length + paddingSize]; // pad
        Buffer.BlockCopy(ciphertext, 0, ciphertextPadded, 0, ciphertext.Length);
    }

    byte[] decrypted = null;
    using (Aes aesAlg = Aes.Create())
    {
        aesAlg.Padding = PaddingMode.None; // must be specified, as PKCS#7 is the default
        aesAlg.Mode = CipherMode.CFB; // must be specified, as CBC is the default
        aesAlg.FeedbackSize = 128; // must be specified, as CFB-8 is the default
        aesAlg.Key = key;
        aesAlg.IV = iv;
        ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
        using (MemoryStream msDecrypt = new MemoryStream(ciphertextPadded))
        {
            using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
            {
                using (MemoryStream msDecryptForCpy = new MemoryStream())
                {
                    csDecrypt.CopyTo(msDecryptForCpy);
                    decrypted = msDecryptForCpy.ToArray();
                }
            }
        }
        return decrypted[..^paddingSize]; // remove padding
    }
}

Teste:

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Security;

...

byte[] plaintext = Encoding.UTF8.GetBytes("{\"business_id\":\"3292aecc-886a-45e3-aa55-d3");
byte[] iv = Convert.FromHexString("76396c566a476c4c50694e376469487a");
byte[] key = Encoding.UTF8.GetBytes("ei9dzmx9f3l2CdFliYMb7iwJ7d0ce58d");

// native C# methods (one shot)
byte[] ciphertext_streams = AesEncrypt_streams(key, iv, plaintext);
Console.WriteLine(Convert.ToBase64String(ciphertext_streams));
byte[] decrypted_streams = AesDecrypt_streams(key, iv, ciphertext_streams);
Console.WriteLine(Encoding.UTF8.GetString(decrypted_streams));

// C#/BouncyCastle methods
byte[] ciphertext_BC = AesEncrypt_BC(key, iv, plaintext);
Console.WriteLine(Convert.ToBase64String(ciphertext_BC));
byte[] decrypted_BC = AesDecrypt_BC(key, iv, ciphertext_BC);
Console.WriteLine(Encoding.UTF8.GetString(decrypted_BC));

// native C# methods (streams)
byte[] ciphertext = AesEncrypt(key, iv, plaintext);
Console.WriteLine(Convert.ToBase64String(ciphertext));
byte[] decrypted = AesDecrypt(key, iv, ciphertext);
Console.WriteLine(Encoding.UTF8.GetString(decrypted));

Saída:

HgnDCsJPaosJkvCF8jqPHUdSOVtCO2GeVQWiBCV9ocDRDM2EGUzNYRXy
{"business_id":"3292aecc-886a-45e3-aa55-d3
HgnDCsJPaosJkvCF8jqPHUdSOVtCO2GeVQWiBCV9ocDRDM2EGUzNYRXy
{"business_id":"3292aecc-886a-45e3-aa55-d3
HgnDCsJPaosJkvCF8jqPHUdSOVtCO2GeVQWiBCV9ocDRDM2EGUzNYRXy
{"business_id":"3292aecc-886a-45e3-aa55-d3