Add PGP encrypt/decrypt functions with files

ballerina/encrypt_decrypt.bal

@@ -260,6 +260,21 @@ public isolated function encryptPgp(byte[] plainText, string publicKeyPath, *Opt
     'class: "io.ballerina.stdlib.crypto.nativeimpl.Encrypt"
 } external;
 
+# Writes the PGP-encrypted value of the given data to a file specified by the output file path.
+# ```ballerina
+# check crypto:encryptPgpAsFile("input.txt", "public_key.asc", "output.txt");
+# ```
+#
+# + inputFilePath - Path to the input file
+# + publicKeyPath - Path to the public key
+# + outputFilePath - Path to the output file
+# + options - PGP encryption options
+# + return - A `crypto:Error` will be returned if the process fails
+public isolated function encryptPgpAsFile(string inputFilePath, string publicKeyPath, string outputFilePath,
+        *Options options) returns Error? = @java:Method {
+    'class: "io.ballerina.stdlib.crypto.nativeimpl.Encrypt"
+} external;
+
 # Returns the PGP-decrypted value of the given PGP-encrypted data.
 # ```ballerina
 # byte[] message = "Hello Ballerina!".toBytes();
@@ -278,3 +293,19 @@ public isolated function decryptPgp(byte[] cipherText, string privateKeyPath, by
     name: "decryptPgp",
     'class: "io.ballerina.stdlib.crypto.nativeimpl.Decrypt"
 } external;
+
+# Writes the PGP-decrypted value of the given data to a file specified by the output file path.
+# ```ballerina
+# byte[] passphrase = check io:fileReadBytes("pass_phrase.txt");
+# check crypto:decryptPgpAsFile("input.txt", "private_key.asc", passphrase, "output.txt");
+# ```
+#
+# + inputFilePath - Path to the input file
+# + privateKeyPath - Path to the private key
+# + passphrase - passphrase of the private key
+# + outputFilePath - Path to the output file
+# + return - A `crypto:Error` will be returned if the process fails
+public isolated function decryptPgpAsFile(string inputFilePath, string privateKeyPath, byte[] passphrase,
+        string outputFilePath) returns Error? = @java:Method {
+    'class: "io.ballerina.stdlib.crypto.nativeimpl.Decrypt"
+} external;

native/src/main/java/io/ballerina/stdlib/crypto/PgpDecryptionGenerator.java

@@ -43,6 +43,8 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.security.Security;
 import java.util.Iterator;
 import java.util.Objects;
@@ -123,6 +125,12 @@ public Object decrypt(byte[] encryptedBytes) throws PGPException, IOException {
         }
     }
 
+    public void decrypt(InputStream encryptedIn, String outputPath) throws PGPException, IOException {
+        try (OutputStream outputStream = Files.newOutputStream(Path.of(outputPath))) {
+            decryptStream(encryptedIn, outputStream);
+        }
+    }
+
     private static void decrypt(OutputStream clearOut, Optional<PGPPrivateKey> pgpPrivateKey,
                         PGPPublicKeyEncryptedData publicKeyEncryptedData) throws IOException, PGPException {
         if (pgpPrivateKey.isPresent()) {

native/src/main/java/io/ballerina/stdlib/crypto/PgpEncryptionGenerator.java

@@ -38,6 +38,8 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.security.SecureRandom;
 import java.security.Security;
 import java.time.LocalDateTime;
@@ -76,7 +78,7 @@ public PgpEncryptionGenerator(int compressionAlgorithm, int symmetricKeyAlgorith
         this.withIntegrityCheck = withIntegrityCheck;
     }
 
-    private void encryptStream(OutputStream encryptOut, InputStream clearIn, long length, InputStream publicKeyIn)
+    private void encryptStream(OutputStream encryptOut, InputStream clearIn, InputStream publicKeyIn)
             throws IOException, PGPException {
         PGPCompressedDataGenerator compressedDataGenerator =
                 new PGPCompressedDataGenerator(compressionAlgorithm);
@@ -95,7 +97,7 @@ private void encryptStream(OutputStream encryptOut, InputStream clearIn, long le
         }
 
         try (OutputStream cipherOutStream = pgpEncryptedDataGenerator.open(encryptOut, new byte[BUFFER_SIZE])) {
-            copyAsLiteralData(compressedDataGenerator.open(cipherOutStream), clearIn, length);
+            copyAsLiteralData(compressedDataGenerator.open(cipherOutStream), clearIn);
             compressedDataGenerator.close();
         }
         encryptOut.close();
@@ -105,11 +107,18 @@ private void encryptStream(OutputStream encryptOut, InputStream clearIn, long le
     public Object encrypt(byte[] clearData, InputStream publicKeyIn) throws PGPException, IOException {
         try (ByteArrayInputStream inputStream = new ByteArrayInputStream(clearData);
              ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
-            encryptStream(outputStream, inputStream, clearData.length, publicKeyIn);
+            encryptStream(outputStream, inputStream, publicKeyIn);
             return ValueCreator.createArrayValue(outputStream.toByteArray());
         }
     }
 
+    public void encrypt(InputStream inputStream, InputStream publicKeyIn, String outputPath)
+            throws PGPException, IOException {
+        try (OutputStream outputStream = Files.newOutputStream(Path.of(outputPath))) {
+            encryptStream(outputStream, inputStream, publicKeyIn);
+        }
+    }
+
     private static PGPPublicKey getPublicKey(InputStream keyInputStream) throws IOException, PGPException {
         PGPPublicKeyRingCollection pgpPublicKeyRings = new PGPPublicKeyRingCollection(
                 PGPUtil.getDecoderStream(keyInputStream), new JcaKeyFingerprintCalculator());
@@ -124,7 +133,7 @@ private static PGPPublicKey getPublicKey(InputStream keyInputStream) throws IOEx
         throw new PGPException("Invalid public key");
     }
 
-    private static void copyAsLiteralData(OutputStream outputStream, InputStream in, long length)
+    private static void copyAsLiteralData(OutputStream outputStream, InputStream in)
             throws IOException {
         PGPLiteralDataGenerator lData = new PGPLiteralDataGenerator();
         byte[] buff = new byte[PgpEncryptionGenerator.BUFFER_SIZE];
@@ -133,10 +142,8 @@ private static void copyAsLiteralData(OutputStream outputStream, InputStream in,
              InputStream inputStream = in) {
 
             int len;
-            long totalBytesWritten = 0L;
-            while (totalBytesWritten <= length && (len = inputStream.read(buff)) > 0) {
+            while ((len = inputStream.read(buff)) > 0) {
                 pOut.write(buff, 0, len);
-                totalBytesWritten += len;
             }
         } finally {
             Arrays.fill(buff, (byte) 0);

native/src/main/java/io/ballerina/stdlib/crypto/nativeimpl/Decrypt.java

@@ -100,4 +100,24 @@ public static Object decryptPgp(BArray cipherTextValue, BString privateKeyPath,
             return CryptoUtils.createError("Error occurred while PGP decrypt: " + e.getMessage());
         }
     }
+
+    public static Object decryptPgpAsFile(BString inputFilePath, BString privateKeyPath, BArray passphrase,
+                                          BString outputFilePath) {
+        byte[] passphraseInBytes = passphrase.getBytes();
+        byte[] privateKey;
+        try {
+            privateKey = Files.readAllBytes(Path.of(privateKeyPath.toString()));
+        } catch (IOException e) {
+            return CryptoUtils.createError("Error occurred while reading public key: " + e.getMessage());
+        }
+
+        try (InputStream keyStream = new ByteArrayInputStream(privateKey);
+             InputStream cipherTextStream = Files.newInputStream(Path.of(inputFilePath.toString()))) {
+            PgpDecryptionGenerator pgpDecryptionGenerator = new PgpDecryptionGenerator(keyStream, passphraseInBytes);
+            pgpDecryptionGenerator.decrypt(cipherTextStream, outputFilePath.getValue());
+            return null;
+        } catch (IOException | PGPException e) {
+            return CryptoUtils.createError("Error occurred while PGP decrypt: " + e.getMessage());
+        }
+    }
 }

native/src/main/java/io/ballerina/stdlib/crypto/nativeimpl/Encrypt.java

@@ -116,4 +116,29 @@ public static Object encryptPgp(BArray plainTextValue, BString publicKeyPath, BM
             return CryptoUtils.createError("Error occurred while PGP encrypt: " + e.getMessage());
         }
     }
+
+    public static Object encryptPgpAsFile(BString inputFilePath, BString publicKeyPath, BString outputFilePath,
+                                          BMap options) {
+        byte[] publicKey;
+        try {
+            publicKey = Files.readAllBytes(Path.of(publicKeyPath.toString()));
+        } catch (IOException e) {
+            return CryptoUtils.createError("Error occurred while reading public key: " + e.getMessage());
+        }
+
+        try (InputStream publicKeyStream = new ByteArrayInputStream(publicKey);
+             InputStream inputStream = Files.newInputStream(Path.of(inputFilePath.toString()))
+        ) {
+            PgpEncryptionGenerator pgpEncryptionGenerator = new PgpEncryptionGenerator(
+                    Integer.parseInt(options.get(COMPRESSION_ALGORITHM).toString()),
+                    Integer.parseInt(options.get(SYMMETRIC_KEY_ALGORITHM).toString()),
+                    Boolean.parseBoolean(options.get(ARMOR).toString()),
+                    Boolean.parseBoolean(options.get(WITH_INTEGRITY_CHECK).toString())
+            );
+            pgpEncryptionGenerator.encrypt(inputStream, publicKeyStream, outputFilePath.getValue());
+            return null;
+        } catch (IOException | PGPException e) {
+            return CryptoUtils.createError("Error occurred while PGP encrypt: " + e.getMessage());
+        }
+    }
 }