Checkstyle issues

pgpainless-core/src/main/kotlin/org/pgpainless/decryption_verification/OpenPgpMessageInputStream.kt

@@ -145,7 +145,8 @@ class OpenPgpMessageInputStream(
 
         // Comsume packets, potentially stepping into nested layers
         layer@ while (run {
-            packet = try {
+            packet =
+                try {
                     pIn.nextPacketTag()
                 } catch (e: NoSuchElementException) {
                     throw MalformedOpenPgpMessageException(e.message)
@@ -212,13 +213,16 @@ class OpenPgpMessageInputStream(
         syntaxVerifier.next(InputSymbol.LITERAL_DATA)
         val literalData = packetInputStream!!.readLiteralData()
 
-        val streamEncoding = try {
+        val streamEncoding =
+            try {
                 StreamEncoding.requireFromCode(literalData.format)
             } catch (e: NoSuchElementException) {
-            throw PGPException("Invalid stream encoding format encountered: ${literalData.format}; ${e.message}")
+                throw PGPException(
+                    "Invalid stream encoding format encountered: ${literalData.format}; ${e.message}")
             }
 
-        val fileName = try {
+        val fileName =
+            try {
                 literalData.fileName
             } catch (e: IllegalArgumentException) {
                 // Non UTF8
@@ -226,11 +230,7 @@ class OpenPgpMessageInputStream(
             }
 
         // Extract Metadata
-        layerMetadata.child =
+        layerMetadata.child = LiteralData(fileName, literalData.modificationTime, streamEncoding)
-            LiteralData(
-                fileName,
-                literalData.modificationTime,
-                streamEncoding)
 
         nestedInputStream = literalData.inputStream
     }
@@ -240,17 +240,15 @@ class OpenPgpMessageInputStream(
         signatures.enterNesting()
         val compressedData = packetInputStream!!.readCompressedData()
 
-        val compAlg = try {
+        val compAlg =
+            try {
                 CompressionAlgorithm.requireFromId(compressedData.algorithm)
             } catch (e: NoSuchElementException) {
                 throw PGPException(e.message)
             }
 
         // Extract Metadata
-        val compressionLayer =
+        val compressionLayer = CompressedData(compAlg, layerMetadata.depth + 1)
-            CompressedData(
-                compAlg,
-                layerMetadata.depth + 1)
 
         LOGGER.debug(
             "Compressed Data Packet (${compressionLayer.algorithm}) at depth ${layerMetadata.depth} encountered.")
@@ -356,7 +354,10 @@ class OpenPgpMessageInputStream(
         }
 
 
-        if (!encDataList.isIntegrityProtected && !encDataList.isEmpty && !encDataList.get(0).isAEAD) {
+
+        if (!encDataList.isIntegrityProtected &&
+            !encDataList.isEmpty &&
+            !encDataList.get(0).isAEAD) {
             LOGGER.warn("Symmetrically Encrypted Data Packet is not integrity-protected.")
             if (!options.isIgnoreMDCErrors()) {
                 throw MessageNotIntegrityProtectedException()
@@ -619,7 +620,8 @@ class OpenPgpMessageInputStream(
         pkesk: PGPPublicKeyEncryptedData
     ): Boolean {
         try {
-            val decrypted = try {
+            val decrypted =
+                try {
                     pkesk.getDataStream(decryptorFactory)
                 } catch (e: ClassCastException) {
                     throw PGPException(e.message)

pgpainless-core/src/main/kotlin/org/pgpainless/signature/SignatureUtils.kt

@@ -165,13 +165,13 @@ class SignatureUtils {
                     // having them compressed,
                     //  except for an attacker who is trying to exploit flaws in the decompression
                     // algorithm.
-                    //  Therefore, we ignore compressed data packets without attempting decompression.
+                    //  Therefore, we ignore compressed data packets without attempting
+                    // decompression.
                     if (nextObject is PGPCompressedData) {
                         // getInputStream() does not do decompression, contrary to getDataStream().
                         Streams.drain(
                             (nextObject as PGPCompressedData)
-                                .inputStream
+                                .inputStream) // Skip packet without decompressing
-                        ) // Skip packet without decompressing
                     }
 
                     if (nextObject is PGPSignatureList) {

pgpainless-core/src/test/kotlin/org/pgpainless/bouncycastle/fuzzing/PGPObjectFactoryFuzzingTest.kt

@@ -6,13 +6,13 @@ package org.pgpainless.bouncycastle.fuzzing
 
 import com.code_intelligence.jazzer.api.FuzzedDataProvider
 import com.code_intelligence.jazzer.junit.FuzzTest
+import java.io.EOFException
+import java.io.IOException
 import org.bouncycastle.bcpg.ArmoredInputException
 import org.bouncycastle.bcpg.UnsupportedPacketVersionException
 import org.bouncycastle.openpgp.PGPException
 import org.bouncycastle.openpgp.PGPUtil
 import org.bouncycastle.openpgp.bc.BcPGPObjectFactory
-import java.io.EOFException
-import java.io.IOException
 
 class PGPObjectFactoryFuzzingTest {
 

pgpainless-sop/src/main/kotlin/org/pgpainless/sop/ArmorImpl.kt

@@ -5,6 +5,7 @@
 package org.pgpainless.sop
 
 import java.io.BufferedOutputStream
+import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
 import kotlin.jvm.Throws
@@ -15,7 +16,6 @@ import org.pgpainless.util.ArmoredOutputStreamFactory
 import sop.Ready
 import sop.exception.SOPGPException
 import sop.operation.Armor
-import java.io.IOException
 
 /** Implementation of the `armor` operation using PGPainless. */
 class ArmorImpl(private val api: PGPainless) : Armor {
@@ -28,13 +28,13 @@ class ArmorImpl(private val api: PGPainless) : Armor {
                 val bufferedOutputStream = BufferedOutputStream(outputStream)
 
                 // Determine the nature of the given data
+
                 val openPgpIn = OpenPGPAnimalSnifferInputStream(data).apply {
                     try {
                         inspectBuffer()
                     } catch (e: IOException) {
                         // ignore
                     }
-                    reset()
                 }
 
                 if (openPgpIn.isAsciiArmored) {

pgpainless-sop/src/main/kotlin/org/pgpainless/sop/DecryptImpl.kt

@@ -4,11 +4,13 @@
 
 package org.pgpainless.sop
 
-import org.bouncycastle.bcpg.UnsupportedPacketVersionException
 import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
 import java.util.*
+import java.util.zip.ZipException
+import kotlin.NoSuchElementException
+import org.bouncycastle.bcpg.UnsupportedPacketVersionException
 import org.bouncycastle.openpgp.PGPException
 import org.bouncycastle.util.io.Streams
 import org.pgpainless.PGPainless
@@ -23,8 +25,6 @@ import sop.ReadyWithResult
 import sop.SessionKey
 import sop.exception.SOPGPException
 import sop.operation.Decrypt
-import java.util.zip.ZipException
-import kotlin.NoSuchElementException
 
 /** Implementation of the `decrypt` operation using PGPainless. */
 class DecryptImpl(private val api: PGPainless) : Decrypt {
@@ -57,8 +57,7 @@ class DecryptImpl(private val api: PGPainless) : Decrypt {
                 throw SOPGPException.BadData(e)
             } catch (e: ModificationDetectionException) {
                 throw SOPGPException.BadData(e)
-            }
+            } finally {
-            finally {
                 // Forget passphrases after decryption
                 protector.clear()
             }