BouncyCastle PGP Decryption issue

[vivekm1817]

Hi there,
I am using BouncyCastle nuget package in the .NET8 project. The Encryption part works fine and I can see the encrypted data in the file but when I try to decrypt using the secret key the pgpObject is null PgpObject pgpObject = pgpObjectFactory.NextPgpObject()
Below is the complete code for the encryption and decryption. I am using test cases to verify the methods

`using Org.BouncyCastle.Bcpg;
using Org.BouncyCastle.Bcpg.OpenPgp;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Utilities.IO;
namespace PGPEncryption
{
public class PgpEncryption : IPgpEncryption
{

   public void EncryptFile(string inputFile, string outputFile, string publicKeyFile)
    {
        using (Stream inputStream = File.OpenRead(inputFile))
        using (Stream publicKeyStream = File.OpenRead(publicKeyFile))
        using (Stream outputStream = File.Create(outputFile))
        {
            Encrypt(inputStream, outputStream, publicKeyStream, true, true);

        }
    }
    public void Encrypt(Stream inputStream, Stream outputStream, Stream publicKeyStream, bool armor, bool withIntegrityCheck)
    {
        PgpPublicKey publicKey = ReadPublicKey(publicKeyStream);
        PgpEncryptedDataGenerator encryptedDataGenerator = new PgpEncryptedDataGenerator(SymmetricKeyAlgorithmTag.Cast5, withIntegrityCheck, new SecureRandom());

        encryptedDataGenerator.AddMethod(publicKey);

        Stream encryptedOut = armor ? new ArmoredOutputStream(outputStream) : outputStream;
        Stream compressedOut = new PgpCompressedDataGenerator(CompressionAlgorithmTag.Zip).Open(encryptedOut);
        Stream literalOut = new PgpLiteralDataGenerator().Open(compressedOut, PgpLiteralData.Binary, "", inputStream.Length, DateTime.UtcNow);

        inputStream.CopyTo(literalOut);

        literalOut.Close();
        compressedOut.Close();
        encryptedOut.Close();
    }


    private PgpPublicKey ReadPublicKey(Stream publicKeyStream)
    {
        PgpPublicKeyRingBundle keyRingBundle = new PgpPublicKeyRingBundle(PgpUtilities.GetDecoderStream(publicKeyStream));

        foreach (PgpPublicKeyRing keyRing in keyRingBundle.GetKeyRings())
        {
            foreach (PgpPublicKey key in keyRing.GetPublicKeys())
            {
                if (key.IsEncryptionKey)
                {
                    return key;
                }
            }
        }

        throw new ArgumentException("No encryption key found in public key ring.");
    }
    public void DecryptFile(string inputFile, string outputFile, string privateKeyFile, string passPhrase)
    {
        using (Stream inputStream = File.OpenRead(inputFile))
        using (Stream privateKeyStream = File.OpenRead(privateKeyFile))
        using (Stream outputStream = File.Create(outputFile))
        {
            Decrypt(inputStream, outputStream, privateKeyStream, passPhrase);
        }
    }
    public void Decrypt(Stream inputStream, Stream outputStream, Stream privateKeyStream, string passPhrase)
    {
        try
        {
            inputStream = PgpUtilities.GetDecoderStream(inputStream);
      
            PgpObjectFactory pgpObjectFactory = new PgpObjectFactory(inputStream);
            PgpEncryptedDataList encryptedDataList = null;
            PgpObject pgpObject = pgpObjectFactory.NextPgpObject();

           
            if (pgpObject is PgpCompressedData)
            {
                PgpCompressedData compressedData = (PgpCompressedData)pgpObject;
                pgpObjectFactory = new PgpObjectFactory(compressedData.GetDataStream());
                pgpObject = pgpObjectFactory.NextPgpObject();
            }

            
            if (pgpObject is PgpEncryptedDataList)
            {
                encryptedDataList = (PgpEncryptedDataList)pgpObject;
            }
            else
            {
                pgpObject = pgpObjectFactory.NextPgpObject();
                if (pgpObject is PgpEncryptedDataList)
                {
                    encryptedDataList = (PgpEncryptedDataList)pgpObject;
                }
                else
                {
                    throw new IOException("Unexpected PGP object in stream: " + pgpObject.GetType().FullName);
                }
            }

            PgpPrivateKey privateKey = null;
            PgpPublicKeyEncryptedData publicKeyEncryptedData = null;

            foreach (PgpPublicKeyEncryptedData encryptedData in encryptedDataList.GetEncryptedDataObjects())
            {
                privateKey = FindPrivateKey(privateKeyStream, encryptedData.KeyId, passPhrase.ToCharArray());
                if (privateKey != null)
                {
                    publicKeyEncryptedData = encryptedData;
                    break;
                }
            }

            if (privateKey == null)
            {
                throw new ArgumentException("Private key for message not found.");
            }

            Stream clearDataStream = publicKeyEncryptedData.GetDataStream(privateKey);
            PgpObjectFactory plainFact = new PgpObjectFactory(clearDataStream);
            PgpObject message = plainFact.NextPgpObject();

            if (message is PgpCompressedData)
            {
                PgpCompressedData compressedData = (PgpCompressedData)message;
                PgpObjectFactory pgpFact = new PgpObjectFactory(compressedData.GetDataStream());
                message = pgpFact.NextPgpObject();
            }

            if (message is PgpLiteralData)
            {
                PgpLiteralData literalData = (PgpLiteralData)message;
                Stream unc = literalData.GetInputStream();
                Streams.PipeAll(unc, outputStream);
            }
            else
            {
                throw new PgpException("Message is not a simple encrypted file.");
            }

            if (publicKeyEncryptedData.IsIntegrityProtected() && !publicKeyEncryptedData.Verify())
            {
                throw new PgpException("Message failed integrity check.");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error during decryption: " + ex.Message);
            throw;
        }
    }


    private PgpPrivateKey FindPrivateKey(Stream privateKeyStream, long keyId, char[] passPhrase)
    {
        PgpSecretKeyRingBundle secretKeyRingBundle = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(privateKeyStream));

        foreach (PgpSecretKeyRing keyRing in secretKeyRingBundle.GetKeyRings())
        {
            foreach (PgpSecretKey secretKey in keyRing.GetSecretKeys())
            {
                if (secretKey.KeyId == keyId)
                {
                    return secretKey.ExtractPrivateKey(passPhrase);
                }
            }
        }

        return null;
    }
}

}
`

Test case
` [Fact]
public void DecryptFile_ShouldCallDecryptWithCorrectParameters()
{
// Arrange
string inputFile = "TestFile";
string encryptedOutputFileName = "testTIKET04P_encp";
string decryptedOutputFileName = "TIKET04P_decp";
string publicKeyFile = "UnitTest_0x0DDD517D_public.asc";
string privateKeyFile = "UnitTest_0x0DDD517D_SECRET.asc";
string passphrase = "";

 var pgpEncryption = new PgpEncryption();

 // Act 

pgpEncryption.EncryptFile(inputFile, encryptedOutputFileName, publicKeyFile);

 // Assert 
 Assert.True(File.Exists(encryptedOutputFileName), $"The file {encryptedOutputFileName} should have been created.");

 // Act - Decrypt the file
 pgpEncryption.DecryptFile(encryptedOutputFileName, decryptedOutputFileName, privateKeyFile, passphrase);

 // Assert - Check if the decrypted file exists
 Assert.True(File.Exists(decryptedOutputFileName), $"The file {decryptedOutputFileName} should have been created.");

  // Clean up
   if (File.Exists(decryptedOutputFileName))
 {
     File.Delete(decryptedOutputFileName);
 }

}`

Not sure which bit is incorrect here. Any help is appreciated. Thanks in advance

[rooyend]

any updates?