Update segmentsOverlap

gefeili · gefeili · commit 9ed602e4b1b9 · 2025-03-28T10:30:16.000+10:30
diff --git a/core/src/main/java/org/bouncycastle/crypto/BufferedBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/BufferedBlockCipher.java
@@ -11,15 +11,15 @@
  */
 public class BufferedBlockCipher
 {
-    protected byte[]        buf;
-    protected int           bufOff;
+    protected byte[] buf;
+    protected int bufOff;
 
-    protected boolean          forEncryption;
-    protected BlockCipher      cipher;
+    protected boolean forEncryption;
+    protected BlockCipher cipher;
     protected MultiBlockCipher mbCipher;
 
-    protected boolean       partialBlockOkay;
-    protected boolean       pgpCFB;
+    protected boolean partialBlockOkay;
+    protected boolean pgpCFB;
 
     /**
      * constructor for subclasses
@@ -35,7 +35,7 @@ public class BufferedBlockCipher
      * @deprecated use the constructor on DefaultBufferedBlockCipher.
      */
     public BufferedBlockCipher(
-        BlockCipher     cipher)
+        BlockCipher cipher)
     {
         this.cipher = cipher;
 
@@ -55,8 +55,8 @@ public BufferedBlockCipher(
         //
         // check if we can handle partial blocks on doFinal.
         //
-        String  name = cipher.getAlgorithmName();
-        int     idx = name.indexOf('/') + 1;
+        String name = cipher.getAlgorithmName();
+        int idx = name.indexOf('/') + 1;
 
         pgpCFB = (idx > 0 && name.startsWith("PGP", idx));
 
@@ -84,14 +84,14 @@ public BlockCipher getUnderlyingCipher()
      * initialise the cipher.
      *
      * @param forEncryption if true the cipher is initialised for
-     *  encryption, if false for decryption.
-     * @param params the key and other data required by the cipher.
-     * @exception IllegalArgumentException if the params argument is
-     * inappropriate.
+     *                      encryption, if false for decryption.
+     * @param params        the key and other data required by the cipher.
+     * @throws IllegalArgumentException if the params argument is
+     *                                  inappropriate.
      */
     public void init(
-        boolean             forEncryption,
-        CipherParameters    params)
+        boolean forEncryption,
+        CipherParameters params)
         throws IllegalArgumentException
     {
         this.forEncryption = forEncryption;
@@ -112,7 +112,7 @@ public int getBlockSize()
     }
 
     /**
-     * return the size of the output buffer required for an update 
+     * return the size of the output buffer required for an update
      * an input of len bytes.
      *
      * @param len the length of the input.
@@ -122,7 +122,7 @@ public int getBlockSize()
     public int getUpdateOutputSize(
         int len)
     {
-        int total       = len + bufOff;
+        int total = len + bufOff;
         int leftOver;
 
         if (pgpCFB)
@@ -138,7 +138,7 @@ public int getUpdateOutputSize(
         }
         else
         {
-            leftOver    = total % buf.length;
+            leftOver = total % buf.length;
         }
 
         return total - leftOver;
@@ -167,20 +167,20 @@ public int getOutputSize(
     /**
      * process a single byte, producing an output block if necessary.
      *
-     * @param in the input byte.
-     * @param out the space for any output that might be produced.
+     * @param in     the input byte.
+     * @param out    the space for any output that might be produced.
      * @param outOff the offset from which the output will be copied.
      * @return the number of output bytes copied to out.
-     * @exception DataLengthException if there isn't enough space in out.
-     * @exception IllegalStateException if the cipher isn't initialised.
+     * @throws DataLengthException   if there isn't enough space in out.
+     * @throws IllegalStateException if the cipher isn't initialised.
      */
     public int processByte(
-        byte        in,
-        byte[]      out,
-        int         outOff)
+        byte in,
+        byte[] out,
+        int outOff)
         throws DataLengthException, IllegalStateException
     {
-        int         resultLen = 0;
+        int resultLen = 0;
 
         buf[bufOff++] = in;
 
@@ -196,31 +196,31 @@ public int processByte(
     /**
      * process an array of bytes, producing output if necessary.
      *
-     * @param in the input byte array.
-     * @param inOff the offset at which the input data starts.
-     * @param len the number of bytes to be copied out of the input array.
-     * @param out the space for any output that might be produced.
+     * @param in     the input byte array.
+     * @param inOff  the offset at which the input data starts.
+     * @param len    the number of bytes to be copied out of the input array.
+     * @param out    the space for any output that might be produced.
      * @param outOff the offset from which the output will be copied.
      * @return the number of output bytes copied to out.
-     * @exception DataLengthException if there isn't enough space in out.
-     * @exception IllegalStateException if the cipher isn't initialised.
+     * @throws DataLengthException   if there isn't enough space in out.
+     * @throws IllegalStateException if the cipher isn't initialised.
      */
     public int processBytes(
-        byte[]      in,
-        int         inOff,
-        int         len,
-        byte[]      out,
-        int         outOff)
+        byte[] in,
+        int inOff,
+        int len,
+        byte[] out,
+        int outOff)
         throws DataLengthException, IllegalStateException
     {
         if (len < 0)
         {
             throw new IllegalArgumentException("Can't have a negative input length!");
         }
 
-        int blockSize   = getBlockSize();
-        int length      = getUpdateOutputSize(len);
-        
+        int blockSize = getBlockSize();
+        int length = getUpdateOutputSize(len);
+
         if (length > 0)
         {
             if ((outOff + length) > out.length)
@@ -237,17 +237,11 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out)
+            if (in == out && segmentsOverlap(inOff, len, outOff, length))
             {
-                int inEnd = inOff + len;
-                int outEnd = outOff + length;
-                if ((inOff <= outOff && outOff <= inEnd) ||
-                    (outOff <= inOff && inOff <= outEnd))
-                {
-                    in = new byte[len];
-                    System.arraycopy(out, inOff, in, 0, len);
-                    inOff = 0;
-                }
+                in = new byte[len];
+                System.arraycopy(out, inOff, in, 0, len);
+                inOff = 0;
             }
 
             resultLen += cipher.processBlock(buf, 0, out, outOff);
@@ -296,20 +290,20 @@ public int processBytes(
     /**
      * Process the last block in the buffer.
      *
-     * @param out the array the block currently being held is copied into.
+     * @param out    the array the block currently being held is copied into.
      * @param outOff the offset at which the copying starts.
      * @return the number of output bytes copied to out.
-     * @exception DataLengthException if there is insufficient space in out for
-     * the output, or the input is not block size aligned and should be.
-     * @exception IllegalStateException if the underlying cipher is not
-     * initialised.
-     * @exception InvalidCipherTextException if padding is expected and not found.
-     * @exception DataLengthException if the input is not block size
-     * aligned.
+     * @throws DataLengthException        if there is insufficient space in out for
+     *                                    the output, or the input is not block size aligned and should be.
+     * @throws IllegalStateException      if the underlying cipher is not
+     *                                    initialised.
+     * @throws InvalidCipherTextException if padding is expected and not found.
+     * @throws DataLengthException        if the input is not block size
+     *                                    aligned.
      */
     public int doFinal(
-        byte[]  out,
-        int     outOff)
+        byte[] out,
+        int outOff)
         throws DataLengthException, IllegalStateException, InvalidCipherTextException
     {
         try
@@ -363,4 +357,10 @@ public void reset()
         //
         cipher.reset();
     }
+
+    protected boolean segmentsOverlap(int inOff, int inLen, int outOff, int outLen)
+    {
+        // please ensure a valid check for inLen > 0 and outLen > 0 outside this function
+        return inOff <= outOff + outLen && outOff <= inOff + inLen;
+    }
 }
diff --git a/core/src/main/java/org/bouncycastle/crypto/DefaultBufferedBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/DefaultBufferedBlockCipher.java
@@ -239,17 +239,11 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out)
+            if (in == out && segmentsOverlap(inOff, len, outOff, length))
             {
-                int inEnd = inOff + len;
-                int outEnd = outOff + length;
-                if ((inOff <= outOff && outOff <= inEnd) ||
-                    (outOff <= inOff && inOff <= outEnd))
-                {
-                    in = new byte[len];
-                    System.arraycopy(out, inOff, in, 0, len);
-                    inOff = 0;
-                }
+                in = new byte[len];
+                System.arraycopy(out, inOff, in, 0, len);
+                inOff = 0;
             }
 
             resultLen += cipher.processBlock(buf, 0, out, outOff);
diff --git a/core/src/main/java/org/bouncycastle/crypto/engines/AEADBaseEngine.java b/core/src/main/java/org/bouncycastle/crypto/engines/AEADBaseEngine.java
@@ -587,17 +587,11 @@ public int processByte(byte input, byte[] output, int outOff)
         @Override
         public int processBytes(byte[] input, int inOff, int len, byte[] output, int outOff)
         {
-            if (input == output)
+            if (input == output && segmentsOverlap(inOff, len, outOff, processor.getUpdateOutputSize(len)))
             {
-                int inEnd = inOff + len;
-                int outEnd = outOff + processor.getUpdateOutputSize(len);
-                if ((inOff <= outOff && outOff <= inEnd) ||
-                    (outOff <= inOff && inOff <= outEnd))
-                {
-                    input = new byte[len];
-                    System.arraycopy(output, inOff, input, 0, len);
-                    inOff = 0;
-                }
+                input = new byte[len];
+                System.arraycopy(output, inOff, input, 0, len);
+                inOff = 0;
             }
             boolean forEncryption = checkData(false);
             if (forEncryption)
@@ -749,17 +743,11 @@ protected int processEncDecBytes(byte[] input, int inOff, int len, byte[] output
         resultLength = length + m_bufPos - (forEncryption ? 0 : MAC_SIZE);
         ensureSufficientOutputBuffer(output, outOff, resultLength - resultLength % BlockSize);
         resultLength = 0;
-        if (input == output)
+        if (input == output && segmentsOverlap(inOff, len, outOff, length))
         {
-            int inEnd = inOff + len;
-            int outEnd = outOff + length;
-            if ((inOff <= outOff && outOff <= inEnd) ||
-                (outOff <= inOff && inOff <= outEnd))
-            {
-                input = new byte[len];
-                System.arraycopy(output, inOff, input, 0, len);
-                inOff = 0;
-            }
+            input = new byte[len];
+            System.arraycopy(output, inOff, input, 0, len);
+            inOff = 0;
         }
         if (forEncryption)
         {
@@ -1039,6 +1027,12 @@ protected void finishAAD3(State nextState, boolean isDoFinal)
         m_state = nextState;
     }
 
+    private boolean segmentsOverlap(int inOff, int inLen, int outOff, int outLen)
+    {
+        // please ensure a valid check for inLen > 0 and outLen > 0 outside this function
+        return inOff <= outOff + outLen && outOff <= inOff + inLen;
+    }
+
     protected abstract void finishAAD(State nextState, boolean isDoFinal);
 
     protected abstract void init(byte[] key, byte[] iv);
diff --git a/core/src/main/java/org/bouncycastle/crypto/modes/CTSBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/modes/CTSBlockCipher.java
@@ -148,17 +148,11 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out)
+            if (in == out && segmentsOverlap(inOff, len, outOff, length))
             {
-                int inEnd = inOff + len;
-                int outEnd = outOff + length;
-                if ((inOff <= outOff && outOff <= inEnd) ||
-                    (outOff <= inOff && inOff <= outEnd))
-                {
-                    in = new byte[len];
-                    System.arraycopy(out, inOff, in, 0, len);
-                    inOff = 0;
-                }
+                in = new byte[len];
+                System.arraycopy(out, inOff, in, 0, len);
+                inOff = 0;
             }
             resultLen += cipher.processBlock(buf, 0, out, outOff);
             System.arraycopy(buf, blockSize, buf, 0, blockSize);
diff --git a/core/src/main/java/org/bouncycastle/crypto/paddings/PaddedBufferedBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/paddings/PaddedBufferedBlockCipher.java
@@ -204,17 +204,11 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out)
+            if (in == out && segmentsOverlap(inOff, len, outOff, length))
             {
-                int inEnd = inOff + len;
-                int outEnd = outOff + length;
-                if ((inOff <= outOff && outOff <= inEnd) ||
-                    (outOff <= inOff && inOff <= outEnd))
-                {
-                    in = new byte[len];
-                    System.arraycopy(out, inOff, in, 0, len);
-                    inOff = 0;
-                }
+                in = new byte[len];
+                System.arraycopy(out, inOff, in, 0, len);
+                inOff = 0;
             }
 
             resultLen += cipher.processBlock(buf, 0, out, outOff);
