Encryption not working using C# System.Security.Cryptography

The CFB mode requires the specification of an additional parameter, namely the segment size, which MS refers to as the feedback size. The segment size specifies the number of encrypted bits per encryption step, see CFB. The segment size is usually appended, e.g. CFB-8 or CFB-128 (CFB-128 is sometimes also referred to as CFB for short).

The CFB mode is not implemented consistently in the various .NET versions. Some versions do not support it at all and some incompletely. Where it is supported, it is not implemented correctly.

.NET 8 (the .NET version you are using) supports CFB-128 (the CFB variant with which the ciphertext HgnDCsJPaosJkvCF8jqPHUdSOVtCO2GeVQWiBCV9ocDRDM2EGUzNYRXy was generated, see CyberChef). However, the .NET implementation is flawed: CFB is a stream cipher mode, so that no padding is required if implemented correctly. In contrast, the MS implementation requires padding to a multiple of the segment size, which for CFB-128 corresponds to a full block (16 bytes for AES). Consequently, the ciphertext must be shortened by the number of padding bytes after encryption.
Since this padding is added before encryption and removed after encryption, meaning that the number of padding bytes is known, no PKCS#7 padding is required, instead a simple padding like zero padding is enough (in particular, it is not necessary to pad a ciphertext that already has the correct length, as PKCS#7 padding does).
Similarly for decryption: the ciphertext must be padded to the required length, and the padding bytes must be removed after decryption.

For the sake of completeness: .NET 8 also supports CFB-8, which is even the default. The segment size for CFB-8 is 8 bits, so that any plaintext length can be encrypted without padding.

CFB-128 encryption/decryption with the native .NET methods:

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
}

With a correct CFB implementation, padding/unpadding is not necessary. For the .NET implementation, however, a missing padding/unpadding results in exceptions. If you use CFB-8 instead of CFB-128, the padding/unpadding can be ommitted.

For comparison, here is the solution with 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);
}

Here, no padding/unpadding is required, no matter how long the plaintext/ciphertext is, as it should be. Note that CFB means CFB-128, while CFB8 refers to CFB-8.

A solution with streams is:

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

Test:

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
byte[] ciphertext = AesEncrypt(key, iv, plaintext);
Console.WriteLine(Convert.ToBase64String(ciphertext));
byte[] decrypted = AesDecrypt(key, iv, ciphertext);
Console.WriteLine(Encoding.UTF8.GetString(decrypted));

// 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_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));

Output:

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