Issue/563 port changes from 2.1.1

CITATION.cff

@@ -24,8 +24,8 @@ preferred-citation:
   doi: 10.3233/SHTI210060
   type: proceedings
 title: "Data Sharing Framework (DSF)"
-version: 2.1.1
-date-released: 2026-04-20
+version: 2.2.0
+date-released: 2026-08-25
 url: https://dsf.dev
 repository-code: https://github.com/datasharingframework/dsf
 repository-artifact: https://github.com/datasharingframework/dsf/releases

dsf-bpe/dsf-bpe-process-api-v2-impl/src/main/java/dev/dsf/bpe/v2/service/CryptoServiceImpl.java

@@ -47,11 +47,15 @@
 import de.hsheilbronn.mi.utils.crypto.keypair.KeyPairGeneratorFactory;
 import de.hsheilbronn.mi.utils.crypto.keypair.KeyPairValidator;
 import de.hsheilbronn.mi.utils.crypto.keystore.KeyStoreCreator;
+import dev.dsf.bpe.v2.service.stream.LimitedInputStream;
 
 public class CryptoServiceImpl implements CryptoService
 {
 	public static final class KemDelegate implements Kem
 	{
+		protected static final long ENCRYPT_LIMIT = 250 * 1024 * 1024; // 250 MiB
+		protected static final long DECRYPT_LIMIT = (250 * 1024 * 1024) + 1024; // 250 MiB + 1024 Bytes
+
 		private final AbstractKemAesGcm delegate;
 
 		public KemDelegate(AbstractKemAesGcm delegate)
@@ -63,15 +67,15 @@ public KemDelegate(AbstractKemAesGcm delegate)
 		public InputStream encrypt(InputStream data, PublicKey publicKey) throws NoSuchAlgorithmException,
 				InvalidKeyException, NoSuchPaddingException, InvalidAlgorithmParameterException
 		{
-			return delegate.encrypt(data, publicKey);
+			return delegate.encrypt(new LimitedInputStream(data, ENCRYPT_LIMIT), publicKey);
 		}
 
 		@Override
 		public InputStream decrypt(InputStream encrypted, PrivateKey privateKey)
 				throws IOException, NoSuchAlgorithmException, InvalidKeyException, DecapsulateException,
 				NoSuchPaddingException, InvalidAlgorithmParameterException
 		{
-			return delegate.decrypt(encrypted, privateKey);
+			return delegate.decrypt(new LimitedInputStream(encrypted, DECRYPT_LIMIT), privateKey);
 		}
 	}
 

dsf-bpe/dsf-bpe-process-api-v2-impl/src/main/java/dev/dsf/bpe/v2/service/stream/LimitedInputStream.java

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2018-2025 Heilbronn University of Applied Sciences
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dev.dsf.bpe.v2.service.stream;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Objects;
+
+/**
+ * An InputStream wrapper that exposes at most a configured number of bytes from the underlying stream.
+ *
+ * <p>
+ * Unlike a regular end-of-stream condition, exhausting the configured limit is treated as a resource limit violation.
+ * Once the configured limit has been exhausted, every subsequent call to {@link #read()} or {@link #skip(long)} throws
+ * {@link IOException}, regardless of whether the underlying stream has reached end-of-stream.
+ * </p>
+ *
+ * <p>
+ * If the underlying stream supports mark/reset, this stream supports it as well. The remaining byte limit is restored
+ * when {@link #reset()} is called.
+ * </p>
+ *
+ * This class is not safe for concurrent use by multiple threads.
+ */
+public final class LimitedInputStream extends FilterInputStream
+{
+	private final long maxBytes;
+
+	private long remainingBytes;
+	private long markedRemaining;
+
+	/**
+	 * Creates a stream that allows reading at most {@code maxBytes} bytes.
+	 *
+	 * @param in
+	 *            the underlying input stream
+	 * @param maxBytes
+	 *            the maximum number of bytes that may be read
+	 * @throws NullPointerException
+	 *             if {@code in} is null
+	 * @throws IllegalArgumentException
+	 *             if {@code maxBytes} is negative
+	 */
+	public LimitedInputStream(InputStream in, long maxBytes)
+	{
+		super(Objects.requireNonNull(in, "in"));
+
+		if (maxBytes < 0)
+			throw new IllegalArgumentException("maxBytes must be >= 0");
+
+		this.maxBytes = maxBytes;
+
+		this.remainingBytes = maxBytes;
+		this.markedRemaining = maxBytes;
+	}
+
+	/**
+	 * Returns the number of bytes that may still be consumed.
+	 *
+	 * @return remaining byte allowance
+	 */
+	public long getRemainingBytes()
+	{
+		return remainingBytes;
+	}
+
+	@Override
+	public int read() throws IOException
+	{
+		ensureRemaining();
+
+		int b = super.read();
+		if (b != -1)
+			remainingBytes--;
+
+		return b;
+	}
+
+	@Override
+	public int read(byte[] b, int off, int len) throws IOException
+	{
+		Objects.checkFromIndexSize(off, len, b.length);
+
+		if (len == 0)
+			return 0;
+
+		ensureRemaining();
+
+		int allowed = (int) Math.min(len, remainingBytes);
+		int count = super.read(b, off, allowed);
+
+		if (count > 0)
+			remainingBytes -= count;
+
+		return count;
+	}
+
+	/**
+	 * Skipping bytes beyond the configured limit is treated as an attempt to consume data beyond the allowed resource
+	 * boundary.
+	 *
+	 * @throws IOException
+	 *             if the limit has already been exhausted
+	 */
+	@Override
+	public long skip(long n) throws IOException
+	{
+		if (n <= 0)
+			return 0;
+
+		ensureRemaining();
+
+		long skipped = super.skip(Math.min(n, remainingBytes));
+		remainingBytes -= skipped;
+
+		return skipped;
+	}
+
+	/**
+	 * Returns the smaller of the underlying available bytes and the remaining byte allowance. This value represents
+	 * bytes available within this wrapper's limit, not necessarily bytes immediately readable.
+	 */
+	@Override
+	public int available() throws IOException
+	{
+		return (int) Math.min(super.available(), remainingBytes);
+	}
+
+	@Override
+	public synchronized void mark(int readlimit)
+	{
+		if (markSupported())
+		{
+			super.mark(readlimit);
+			markedRemaining = remainingBytes;
+		}
+	}
+
+	@Override
+	public synchronized void reset() throws IOException
+	{
+		super.reset();
+		remainingBytes = markedRemaining;
+	}
+
+	private void ensureRemaining() throws IOException
+	{
+		if (remainingBytes == 0)
+			throw new IOException("Stream limit of " + maxBytes + " byte" + (maxBytes != 1 ? "s" : "") + " exceeded");
+	}
+}

dsf-bpe/dsf-bpe-process-api-v2-impl/src/test/java/dev/dsf/bpe/v2/service/CryptoServiceTest.java

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2018-2025 Heilbronn University of Applied Sciences
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package dev.dsf.bpe.v2.service;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.KeyPair;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+import de.hsheilbronn.mi.utils.crypto.kem.AbstractKemAesGcm;
+import de.hsheilbronn.mi.utils.crypto.kem.EcDhKemAesGcm;
+import de.hsheilbronn.mi.utils.crypto.kem.RsaKemAesGcm;
+import de.hsheilbronn.mi.utils.crypto.keypair.KeyPairGeneratorFactory;
+import dev.dsf.bpe.v2.service.CryptoService.Kem;
+import dev.dsf.bpe.v2.service.CryptoServiceImpl.KemDelegate;
+
+@RunWith(Parameterized.class)
+public class CryptoServiceTest
+{
+	private static final class ZeroInputStream extends InputStream
+	{
+		private final long size;
+		private long position = 0;
+
+		public ZeroInputStream(long size)
+		{
+			this.size = size;
+		}
+
+		@Override
+		public int read() throws IOException
+		{
+			if (position >= size)
+				return -1;
+
+			position++;
+			return 0;
+		}
+
+		@Override
+		public int read(byte[] b, int off, int len) throws IOException
+		{
+			if (position >= size)
+				return -1;
+
+			int bytesToRead = (int) Math.min(len, size - position);
+
+			for (int i = 0; i < bytesToRead; i++)
+				b[off + i] = 0;
+
+			position += bytesToRead;
+			return bytesToRead;
+		}
+
+		@Override
+		public long skip(long n) throws IOException
+		{
+			long skipped = Math.min(n, size - position);
+			position += skipped;
+			return skipped;
+		}
+
+		@Override
+		public int available() throws IOException
+		{
+			long remaining = size - position;
+			return remaining > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) remaining;
+		}
+
+		@Override
+		public void close() throws IOException
+		{
+			// nothing to do
+		}
+	}
+
+	@Parameters
+	public static Object[][] data()
+	{
+		CryptoService cryptoService = new CryptoServiceImpl();
+
+		return new Object[][] {
+				{ cryptoService.createKeyPairGeneratorX25519AndInitialize().genKeyPair(), cryptoService.createEcDhKem(),
+						new EcDhKemAesGcm() },
+				{ cryptoService.createKeyPairGeneratorX448AndInitialize().genKeyPair(), cryptoService.createEcDhKem(),
+						new EcDhKemAesGcm() },
+				{ KeyPairGeneratorFactory.rsa1024().initialize().generateKeyPair(), cryptoService.createRsaKem(),
+						new RsaKemAesGcm() },
+				{ cryptoService.createKeyPairGeneratorRsa4096AndInitialize().generateKeyPair(),
+						cryptoService.createRsaKem(), new RsaKemAesGcm() } };
+	}
+
+	@Parameter(0)
+	public KeyPair keyPair;
+
+	@Parameter(1)
+	public Kem kem;
+
+	@Parameter(2)
+	public AbstractKemAesGcm noLimitKem;
+
+	@Test
+	public void testEncryptionLimit() throws Exception
+	{
+		try
+		{
+			kem.encrypt(new ZeroInputStream(KemDelegate.ENCRYPT_LIMIT + 1), keyPair.getPublic())
+					.transferTo(OutputStream.nullOutputStream());
+
+			fail("Expected IOException");
+		}
+		catch (IOException e)
+		{
+			assertEquals("Stream limit of " + KemDelegate.ENCRYPT_LIMIT + " bytes exceeded", e.getMessage());
+		}
+	}
+
+	@Test
+	public void testDecryptLimit() throws Exception
+	{
+		try
+		{
+			InputStream encrypted = noLimitKem.encrypt(new ZeroInputStream(KemDelegate.DECRYPT_LIMIT + 1),
+					keyPair.getPublic());
+
+			kem.decrypt(encrypted, keyPair.getPrivate()).transferTo(OutputStream.nullOutputStream());
+
+			fail("Expected IOException");
+		}
+		catch (IOException e)
+		{
+			assertEquals("Stream limit of " + KemDelegate.DECRYPT_LIMIT + " bytes exceeded", e.getMessage());
+		}
+	}
+}