Move segmentsOverlap methods to Arrays class

peterdettman · peterdettman · commit 134689f7ee3d · 2025-05-29T15:15:37.000+07:00
diff --git a/core/src/main/java/org/bouncycastle/crypto/BufferedBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/BufferedBlockCipher.java
@@ -1,5 +1,6 @@
 package org.bouncycastle.crypto;
 
+import org.bouncycastle.util.Arrays;
 
 /**
  * A wrapper class that allows block ciphers to be used to process data in
@@ -237,7 +238,7 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out && segmentsOverlap(inOff, len, outOff, length))
+            if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, length))
             {
                 in = new byte[len];
                 System.arraycopy(out, inOff, in, 0, len);
@@ -357,10 +358,4 @@ 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
@@ -1,5 +1,6 @@
 package org.bouncycastle.crypto;
 
+import org.bouncycastle.util.Arrays;
 
 /**
  * A wrapper class that allows block ciphers to be used to process data in
@@ -239,7 +240,7 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out && segmentsOverlap(inOff, len, outOff, length))
+            if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, length))
             {
                 in = new byte[len];
                 System.arraycopy(out, inOff, in, 0, len);
diff --git a/core/src/main/java/org/bouncycastle/crypto/DefaultMultiBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/DefaultMultiBlockCipher.java
@@ -1,5 +1,7 @@
 package org.bouncycastle.crypto;
 
+import org.bouncycastle.util.Arrays;
+
 public abstract class DefaultMultiBlockCipher
     implements MultiBlockCipher
 {
@@ -21,7 +23,7 @@ public int processBlocks(byte[] in, int inOff, int blockCount, byte[] out, int o
         int resultLen = 0;
         int blockSize = this.getMultiBlockSize();
         int len = blockCount * blockSize;
-        if (in == out && segmentsOverlap(inOff, len, outOff, len))
+        if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, len))
         {
             in = new byte[len];
             System.arraycopy(out, inOff, in, 0, len);
@@ -36,10 +38,4 @@ public int processBlocks(byte[] in, int inOff, int blockCount, byte[] out, int o
 
         return resultLen;
     }
-
-    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/engines/AEADBaseEngine.java b/core/src/main/java/org/bouncycastle/crypto/engines/AEADBaseEngine.java
@@ -637,7 +637,7 @@ 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 && segmentsOverlap(inOff, len, outOff, processor.getUpdateOutputSize(len)))
+            if (input == output && Arrays.segmentsOverlap(inOff, len, outOff, processor.getUpdateOutputSize(len)))
             {
                 input = new byte[len];
                 System.arraycopy(output, inOff, input, 0, len);
@@ -793,7 +793,7 @@ 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 && segmentsOverlap(inOff, len, outOff, length))
+        if (input == output && Arrays.segmentsOverlap(inOff, len, outOff, length))
         {
             input = new byte[len];
             System.arraycopy(output, inOff, input, 0, len);
@@ -1077,12 +1077,6 @@ 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
@@ -6,6 +6,7 @@
 import org.bouncycastle.crypto.InvalidCipherTextException;
 import org.bouncycastle.crypto.OutputLengthException;
 import org.bouncycastle.crypto.StreamBlockCipher;
+import org.bouncycastle.util.Arrays;
 
 /**
  * A Cipher Text Stealing (CTS) mode cipher. CTS allows block ciphers to
@@ -148,7 +149,7 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out && segmentsOverlap(inOff, len, outOff, length))
+            if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, length))
             {
                 in = new byte[len];
                 System.arraycopy(out, inOff, in, 0, len);
diff --git a/core/src/main/java/org/bouncycastle/crypto/modes/ChaCha20Poly1305.java b/core/src/main/java/org/bouncycastle/crypto/modes/ChaCha20Poly1305.java
@@ -307,7 +307,7 @@ public int processBytes(byte[] in, int inOff, int len, byte[] out, int outOff) t
         {
             throw new IllegalArgumentException("'outOff' cannot be negative");
         }
-        if (in == out && segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))
+        if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))
         {
             in = new byte[len];
             System.arraycopy(out, inOff, in, 0, len);
@@ -617,10 +617,4 @@ private void reset(boolean clearMac, boolean resetCipher)
             processAADBytes(initialAAD, 0, initialAAD.length);
         }
     }
-
-    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/modes/EAXBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/modes/EAXBlockCipher.java
@@ -224,7 +224,7 @@ public int processBytes(byte[] in, int inOff, int len, byte[] out, int outOff)
         {
             throw new DataLengthException("Input buffer too short");
         }
-        if (in == out && segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))
+        if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))
         {
             in = new byte[len];
             System.arraycopy(out, inOff, in, 0, len);
@@ -390,10 +390,4 @@ private boolean verifyMac(byte[] mac, int off)
 
         return nonEqual == 0;
     }
-
-    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/modes/GCMBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/modes/GCMBlockCipher.java
@@ -383,7 +383,7 @@ public int processBytes(byte[] in, int inOff, int len, byte[] out, int outOff)
         {
             throw new DataLengthException("Input buffer too short");
         }
-        if (in == out && segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))
+        if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))
         {
             in = new byte[len];
             System.arraycopy(out, inOff, in, 0, len);
@@ -754,10 +754,4 @@ private void checkStatus()
             throw new IllegalStateException("GCM cipher needs to be initialised");
         }
     }
-
-    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/modes/KXTSBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/modes/KXTSBlockCipher.java
@@ -6,6 +6,7 @@
 import org.bouncycastle.crypto.DefaultBufferedBlockCipher;
 import org.bouncycastle.crypto.OutputLengthException;
 import org.bouncycastle.crypto.params.ParametersWithIV;
+import org.bouncycastle.util.Arrays;
 import org.bouncycastle.util.Pack;
 
 /**
@@ -123,21 +124,21 @@ public int processBytes(byte[] input, int inOff, int len, byte[] output, int out
         {
             throw new IllegalArgumentException("Partial blocks not supported");
         }
-        if (input == output && segmentsOverlap(inOff, len, outOff, len))
+        if (input == output && Arrays.segmentsOverlap(inOff, len, outOff, len))
         {
             input = new byte[len];
             System.arraycopy(output, inOff, input, 0, len);
             inOff = 0;
         }
         for (int pos = 0; pos < len; pos += blockSize)
         {
-            processBlocks(input, inOff + pos, output, outOff + pos);
+            processBlock(input, inOff + pos, output, outOff + pos);
         }
 
         return len;
     }
 
-    private void processBlocks(byte[] input, int inOff, byte[] output, int outOff)
+    private void processBlock(byte[] input, int inOff, byte[] output, int outOff)
     {
         /*
          * A somewhat arbitrary limit of 2^32 - 1 blocks
diff --git a/core/src/main/java/org/bouncycastle/crypto/modes/NISTCTSBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/modes/NISTCTSBlockCipher.java
@@ -9,6 +9,7 @@
 import org.bouncycastle.crypto.DefaultBufferedBlockCipher;
 import org.bouncycastle.crypto.InvalidCipherTextException;
 import org.bouncycastle.crypto.OutputLengthException;
+import org.bouncycastle.util.Arrays;
 
 /**
  * A Cipher Text Stealing (CTS) mode cipher. CTS allows block ciphers to
@@ -157,7 +158,7 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out && segmentsOverlap(inOff, len, outOff, length))
+            if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, length))
             {
                 in = new byte[len];
                 System.arraycopy(out, inOff, in, 0, len);
diff --git a/core/src/main/java/org/bouncycastle/crypto/modes/OCBBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/modes/OCBBlockCipher.java
@@ -333,7 +333,7 @@ public int processBytes(byte[] input, int inOff, int len, byte[] output, int out
             throw new DataLengthException("Input buffer too short");
         }
         int resultLen = 0;
-        if (input == output && segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))
+        if (input == output && Arrays.segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))
         {
             input = new byte[len];
             System.arraycopy(output, inOff, input, 0, len);
@@ -597,10 +597,4 @@ protected static void xor(byte[] block, byte[] val)
     {
         Bytes.xorTo(16, val, block);
     }
-
-    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/modes/OldCTSBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/modes/OldCTSBlockCipher.java
@@ -5,6 +5,7 @@
 import org.bouncycastle.crypto.DefaultBufferedBlockCipher;
 import org.bouncycastle.crypto.InvalidCipherTextException;
 import org.bouncycastle.crypto.OutputLengthException;
+import org.bouncycastle.util.Arrays;
 
 /**
  * A Cipher Text Stealing (CTS) mode cipher. CTS allows block ciphers to
@@ -151,7 +152,7 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out && segmentsOverlap(inOff, len, outOff, length))
+            if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, length))
             {
                 in = new byte[len];
                 System.arraycopy(out, inOff, in, 0, len);
diff --git a/core/src/main/java/org/bouncycastle/crypto/paddings/PaddedBufferedBlockCipher.java b/core/src/main/java/org/bouncycastle/crypto/paddings/PaddedBufferedBlockCipher.java
@@ -7,6 +7,7 @@
 import org.bouncycastle.crypto.InvalidCipherTextException;
 import org.bouncycastle.crypto.OutputLengthException;
 import org.bouncycastle.crypto.params.ParametersWithRandom;
+import org.bouncycastle.util.Arrays;
 
 /**
  * A wrapper class that allows block ciphers to be used to process data in
@@ -204,7 +205,7 @@ public int processBytes(
             System.arraycopy(in, inOff, buf, bufOff, gapLen);
             inOff += gapLen;
             len -= gapLen;
-            if (in == out && segmentsOverlap(inOff, len, outOff, length))
+            if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, length))
             {
                 in = new byte[len];
                 System.arraycopy(out, inOff, in, 0, len);
diff --git a/core/src/main/java/org/bouncycastle/util/Arrays.java b/core/src/main/java/org/bouncycastle/util/Arrays.java
@@ -1249,6 +1249,14 @@ public static boolean isNullOrEmpty(Object[] array)
         return null == array || array.length < 1;
     }
 
+    public static boolean segmentsOverlap(int aOff, int aLen, int bOff, int bLen)
+    {
+        return aLen > 0
+            && bLen > 0
+            && aOff - bOff < bLen
+            && bOff - aOff < aLen;
+    }
+
     public static void validateRange(byte[] buf, int from, int to)
     {
         if (buf == null)

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,7 @@`
`1`	`1`	`package org.bouncycastle.crypto;`
`2`	`2`
	`3`	`+import org.bouncycastle.util.Arrays;`
	`4`	`+`
`3`	`5`	`public abstract class DefaultMultiBlockCipher`
`4`	`6`	`implements MultiBlockCipher`
`5`	`7`	`{`
`@@ -21,7 +23,7 @@ public int processBlocks(byte[] in, int inOff, int blockCount, byte[] out, int o`
`21`	`23`	`int resultLen = 0;`
`22`	`24`	`int blockSize = this.getMultiBlockSize();`
`23`	`25`	`int len = blockCount * blockSize;`
`24`		`- if (in == out && segmentsOverlap(inOff, len, outOff, len))`
	`26`	`+ if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, len))`
`25`	`27`	`{`
`26`	`28`	`in = new byte[len];`
`27`	`29`	`System.arraycopy(out, inOff, in, 0, len);`
`@@ -36,10 +38,4 @@ public int processBlocks(byte[] in, int inOff, int blockCount, byte[] out, int o`
`36`	`38`
`37`	`39`	`return resultLen;`
`38`	`40`	`}`
`39`		`-`
`40`		`- protected boolean segmentsOverlap(int inOff, int inLen, int outOff, int outLen)`
`41`		`- {`
`42`		`- // please ensure a valid check for inLen > 0 and outLen > 0 outside this function`
`43`		`- return inOff <= outOff + outLen && outOff <= inOff + inLen;`
`44`		`- }`
`45`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -307,7 +307,7 @@ public int processBytes(byte[] in, int inOff, int len, byte[] out, int outOff) t`
`307`	`307`	`{`
`308`	`308`	`throw new IllegalArgumentException("'outOff' cannot be negative");`
`309`	`309`	`}`
`310`		`- if (in == out && segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))`
	`310`	`+ if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))`
`311`	`311`	`{`
`312`	`312`	`in = new byte[len];`
`313`	`313`	`System.arraycopy(out, inOff, in, 0, len);`
`@@ -617,10 +617,4 @@ private void reset(boolean clearMac, boolean resetCipher)`
`617`	`617`	`processAADBytes(initialAAD, 0, initialAAD.length);`
`618`	`618`	`}`
`619`	`619`	`}`
`620`		`-`
`621`		`- protected boolean segmentsOverlap(int inOff, int inLen, int outOff, int outLen)`
`622`		`- {`
`623`		`- // please ensure a valid check for inLen > 0 and outLen > 0 outside this function`
`624`		`- return inOff <= outOff + outLen && outOff <= inOff + inLen;`
`625`		`- }`
`626`	`620`	`}`
Original file line number	Diff line number	Diff line change
`@@ -224,7 +224,7 @@ public int processBytes(byte[] in, int inOff, int len, byte[] out, int outOff)`
`224`	`224`	`{`
`225`	`225`	`throw new DataLengthException("Input buffer too short");`
`226`	`226`	`}`
`227`		`- if (in == out && segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))`
	`227`	`+ if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))`
`228`	`228`	`{`
`229`	`229`	`in = new byte[len];`
`230`	`230`	`System.arraycopy(out, inOff, in, 0, len);`
`@@ -390,10 +390,4 @@ private boolean verifyMac(byte[] mac, int off)`
`390`	`390`
`391`	`391`	`return nonEqual == 0;`
`392`	`392`	`}`
`393`		`-`
`394`		`- protected boolean segmentsOverlap(int inOff, int inLen, int outOff, int outLen)`
`395`		`- {`
`396`		`- // please ensure a valid check for inLen > 0 and outLen > 0 outside this function`
`397`		`- return inOff <= outOff + outLen && outOff <= inOff + inLen;`
`398`		`- }`
`399`	`393`	`}`
Original file line number	Diff line number	Diff line change
`@@ -383,7 +383,7 @@ public int processBytes(byte[] in, int inOff, int len, byte[] out, int outOff)`
`383`	`383`	`{`
`384`	`384`	`throw new DataLengthException("Input buffer too short");`
`385`	`385`	`}`
`386`		`- if (in == out && segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))`
	`386`	`+ if (in == out && Arrays.segmentsOverlap(inOff, len, outOff, getUpdateOutputSize(len)))`
`387`	`387`	`{`
`388`	`388`	`in = new byte[len];`
`389`	`389`	`System.arraycopy(out, inOff, in, 0, len);`
`@@ -754,10 +754,4 @@ private void checkStatus()`
`754`	`754`	`throw new IllegalStateException("GCM cipher needs to be initialised");`
`755`	`755`	`}`
`756`	`756`	`}`
`757`		`-`
`758`		`- protected boolean segmentsOverlap(int inOff, int inLen, int outOff, int outLen)`
`759`		`- {`
`760`		`- // please ensure a valid check for inLen > 0 and outLen > 0 outside this function`
`761`		`- return inOff <= outOff + outLen && outOff <= inOff + inLen;`
`762`		`- }`
`763`	`757`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`	`import org.bouncycastle.crypto.DefaultBufferedBlockCipher;`
`7`	`7`	`import org.bouncycastle.crypto.OutputLengthException;`
`8`	`8`	`import org.bouncycastle.crypto.params.ParametersWithIV;`
	`9`	`+import org.bouncycastle.util.Arrays;`
`9`	`10`	`import org.bouncycastle.util.Pack;`
`10`	`11`
`11`	`12`	`/**`
`@@ -123,21 +124,21 @@ public int processBytes(byte[] input, int inOff, int len, byte[] output, int out`
`123`	`124`	`{`
`124`	`125`	`throw new IllegalArgumentException("Partial blocks not supported");`
`125`	`126`	`}`
`126`		`- if (input == output && segmentsOverlap(inOff, len, outOff, len))`
	`127`	`+ if (input == output && Arrays.segmentsOverlap(inOff, len, outOff, len))`
`127`	`128`	`{`
`128`	`129`	`input = new byte[len];`
`129`	`130`	`System.arraycopy(output, inOff, input, 0, len);`
`130`	`131`	`inOff = 0;`
`131`	`132`	`}`
`132`	`133`	`for (int pos = 0; pos < len; pos += blockSize)`
`133`	`134`	`{`
`134`		`- processBlocks(input, inOff + pos, output, outOff + pos);`
	`135`	`+ processBlock(input, inOff + pos, output, outOff + pos);`
`135`	`136`	`}`
`136`	`137`
`137`	`138`	`return len;`
`138`	`139`	`}`
`139`	`140`
`140`		`- private void processBlocks(byte[] input, int inOff, byte[] output, int outOff)`
	`141`	`+ private void processBlock(byte[] input, int inOff, byte[] output, int outOff)`
`141`	`142`	`{`
`142`	`143`	`/*`
`143`	`144`	`* A somewhat arbitrary limit of 2^32 - 1 blocks`