Checkstyle issues

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

@@ -139,11 +139,12 @@ class OpenPgpMessageInputStream(
 
         // Comsume packets, potentially stepping into nested layers
         layer@ while (run {
-            packet = try {
+            packet =
-                pIn.nextPacketTag()
+                try {
-            } catch (e: NoSuchElementException) {
+                    pIn.nextPacketTag()
-                throw MalformedOpenPgpMessageException(e.message)
+                } catch (e: NoSuchElementException) {
-            }
+                    throw MalformedOpenPgpMessageException(e.message)
+                }
             packet
         } != null) {
 
@@ -210,25 +211,24 @@ class OpenPgpMessageInputStream(
         syntaxVerifier.next(InputSymbol.LITERAL_DATA)
         val literalData = packetInputStream!!.readLiteralData()
 
-        val streamEncoding = try {
+        val streamEncoding =
-            StreamEncoding.requireFromCode(literalData.format)
+            try {
-        } catch (e: NoSuchElementException) {
+                StreamEncoding.requireFromCode(literalData.format)
-            throw PGPException("Invalid stream encoding format encountered: ${literalData.format}; ${e.message}")
+            } catch (e: NoSuchElementException) {
-        }
+                throw PGPException(
+                    "Invalid stream encoding format encountered: ${literalData.format}; ${e.message}")
+            }
 
-        val fileName = try {
+        val fileName =
-            literalData.fileName
+            try {
-        } catch (e: IllegalArgumentException) {
+                literalData.fileName
-            // Non UTF8
+            } catch (e: IllegalArgumentException) {
-            throw PGPException("Cannot decode literal data filename: ${e.message}")
+                // Non UTF8
-        }
+                throw PGPException("Cannot decode literal data filename: ${e.message}")
+            }
 
         // Extract Metadata
-        layerMetadata.child =
+        layerMetadata.child = LiteralData(fileName, literalData.modificationTime, streamEncoding)
-            LiteralData(
-                fileName,
-                literalData.modificationTime,
-                streamEncoding)
 
         nestedInputStream = literalData.inputStream
     }
@@ -238,17 +238,15 @@ class OpenPgpMessageInputStream(
         signatures.enterNesting()
         val compressedData = packetInputStream!!.readCompressedData()
 
-        val compAlg = try {
+        val compAlg =
-            CompressionAlgorithm.requireFromId(compressedData.algorithm)
+            try {
-        } catch (e: NoSuchElementException) {
+                CompressionAlgorithm.requireFromId(compressedData.algorithm)
-            throw PGPException(e.message)
+            } 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.")
@@ -347,7 +345,9 @@ class OpenPgpMessageInputStream(
             "Symmetrically Encrypted Data Packet at depth ${layerMetadata.depth} encountered.")
         syntaxVerifier.next(InputSymbol.ENCRYPTED_DATA)
         val encDataList = packetInputStream!!.readEncryptedDataList()
-        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()
@@ -569,13 +569,14 @@ class OpenPgpMessageInputStream(
         pkesk: PGPPublicKeyEncryptedData
     ): Boolean {
         try {
-            val decrypted = try {
+            val decrypted =
-                pkesk.getDataStream(decryptorFactory)
+                try {
-            } catch (e: ClassCastException) {
+                    pkesk.getDataStream(decryptorFactory)
-                throw PGPException(e.message)
+                } catch (e: ClassCastException) {
-            } catch (e: IllegalArgumentException) {
+                    throw PGPException(e.message)
-                throw PGPException(e.message)
+                } catch (e: IllegalArgumentException) {
-            }
+                    throw PGPException(e.message)
+                }
             val sessionKey = SessionKey(pkesk.getSessionKey(decryptorFactory))
             throwIfUnacceptable(sessionKey.algorithm)
 

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/main/kotlin/org/pgpainless/util/ArmorUtils.kt

@@ -247,7 +247,8 @@ class ArmorUtils {
                 .add(OpenPgpFingerprint.of(publicKey).prettyPrint())
             // Primary / First User ID
             (primary ?: first)?.let {
-                headerMap.getOrPut(HEADER_COMMENT) { mutableSetOf() }
+                headerMap
+                    .getOrPut(HEADER_COMMENT) { mutableSetOf() }
                     .add(it.replace("\n", "\\n").replace("\r", "\\r"))
             }
             // X-1 further identities

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
@@ -14,7 +15,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 : Armor {
@@ -27,14 +27,15 @@ class ArmorImpl : Armor {
                 val bufferedOutputStream = BufferedOutputStream(outputStream)
 
                 // Determine the nature of the given data
-                val openPgpIn = OpenPgpInputStream(data, false).apply {
+                val openPgpIn =
-                    try {
+                    OpenPgpInputStream(data, false).apply {
-                        inspectBuffer()
+                        try {
-                    } catch (e: IOException) {
+                            inspectBuffer()
-                        // ignore
+                        } catch (e: IOException) {
+                            // ignore
+                        }
+                        reset()
                     }
-                    reset()
-                }
 
                 if (openPgpIn.isAsciiArmored) {
                     // armoring already-armored data is an idempotent operation

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
@@ -25,8 +27,6 @@ import sop.SessionKey
 import sop.exception.SOPGPException
 import sop.operation.Decrypt
 import sop.util.UTF8Util
-import java.util.zip.ZipException
-import kotlin.NoSuchElementException
 
 /** Implementation of the `decrypt` operation using PGPainless. */
 class DecryptImpl : Decrypt {
@@ -61,8 +61,7 @@ class DecryptImpl : Decrypt {
                 throw SOPGPException.BadData(e)
             } catch (e: ModificationDetectionException) {
                 throw SOPGPException.BadData(e)
-            }
+            } finally {
-            finally {
                 // Forget passphrases after decryption
                 protector.clear()
             }