diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
new file mode 100644
index 00000000..d869f67e
--- /dev/null
+++ b/phpstan-baseline.neon
@@ -0,0 +1,11 @@
+parameters:
+	ignoreErrors:
+		-
+			message: "#^Call to an undefined static method SimpleSAML\\\\XML\\\\SerializableElementInterface\\:\\:getNameSpaceURI\\(\\)\\.$#"
+			count: 1
+			path: src/XML/ds/KeyValue.php
+
+		-
+			message: "#^Call to an undefined static method SimpleSAML\\\\XML\\\\SerializableElementInterface\\:\\:getNameSpaceURI\\(\\)\\.$#"
+			count: 1
+			path: src/XML/dsig11/AbstractFieldIDType.php
diff --git a/phpstan.neon b/phpstan.neon
index db37782f..e266e4a4 100644
--- a/phpstan.neon
+++ b/phpstan.neon
@@ -2,3 +2,5 @@ parameters:
   level: 6
   paths:
     - src
+includes:
+  - phpstan-baseline.neon
diff --git a/src/Constants.php b/src/Constants.php
index 402d43e5..0e0565b4 100644
--- a/src/Constants.php
+++ b/src/Constants.php
@@ -144,9 +144,12 @@ class Constants extends \SimpleSAML\XML\Constants
      */
     public const NS_XDSIG = 'http://www.w3.org/2000/09/xmldsig#';
     public const NS_XDSIG11 = 'http://www.w3.org/2009/xmldsig11#';
+
     public const XMLDSIG_ENVELOPED = 'http://www.w3.org/2000/09/xmldsig#enveloped-signature';
     public const XMLDSIG_MANIFEST = 'http://www.w3.org/2000/09/xmldsig#Manifest';
 
+    public const XMLDSIG11_DER_ENCODED_KEY_VALUE = 'https://www.w3.org/2009/xmldsig11#DEREncodedKeyValue';
+
     public const NS_XENC = 'http://www.w3.org/2001/04/xmlenc#';
     public const NS_XENC11 = 'http://www.w3.org/2009/xmlenc11#';
     public const XMLENC_CONTENT = 'http://www.w3.org/2001/04/xmlenc#Content';
diff --git a/src/XML/ds/AbstractKeyInfoType.php b/src/XML/ds/AbstractKeyInfoType.php
index dadff6fc..205869ac 100644
--- a/src/XML/ds/AbstractKeyInfoType.php
+++ b/src/XML/ds/AbstractKeyInfoType.php
@@ -12,7 +12,8 @@
 use SimpleSAML\XMLSecurity\Assert\Assert;
 use SimpleSAML\XMLSecurity\Constants as C;
 use SimpleSAML\XMLSecurity\Exception\InvalidArgumentException;
-use SimpleSAML\XMLSecurity\XML\ds\AbstractDsElement;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\DEREncodedKeyValue;
 
 /**
  * Abstract class representing the KeyInfoType.
@@ -38,6 +39,7 @@ abstract class AbstractKeyInfoType extends AbstractDsElement
      *     \SimpleSAML\XMLSecurity\XML\ds\PGPData|
      *     \SimpleSAML\XMLSecurity\XML\ds\SPKIData|
      *     \SimpleSAML\XMLSecurity\XML\ds\MgmtData|
+     *     \SimpleSAML\XMLSecurity\XML\dsig11\DEREncodedKeyValue|
      *     \SimpleSAML\XML\SerializableElementInterface
      * )[] $info
      * @param string|null $Id
@@ -78,6 +80,14 @@ final public function __construct(
                     ],
                     SchemaViolationException::class,
                 );
+            } elseif ($item instanceof AbstractDsig11Element) {
+                Assert::isInstanceOfAny(
+                    $item,
+                    [
+                        DEREncodedKeyValue::class,
+                    ],
+                    SchemaViolationException::class,
+                );
             }
         }
     }
diff --git a/src/XML/ds/KeyInfo.php b/src/XML/ds/KeyInfo.php
index 01cb7c13..b64ecd0c 100644
--- a/src/XML/ds/KeyInfo.php
+++ b/src/XML/ds/KeyInfo.php
@@ -7,8 +7,8 @@
 use DOMElement;
 use SimpleSAML\Assert\Assert;
 use SimpleSAML\XML\Exception\InvalidDOMElementException;
-use SimpleSAML\XML\SchemaValidatableElementInterface;
-use SimpleSAML\XML\SchemaValidatableElementTrait;
+use SimpleSAML\XML\{SchemaValidatableElementInterface, SchemaValidatableElementTrait};
+use SimpleSAML\XMLSecurity\XML\dsig11\DEREncodedKeyValue;
 
 use function array_merge;
 
@@ -44,6 +44,7 @@ public static function fromXML(DOMElement $xml): static
         $pgpData = PGPData::getChildrenOfClass($xml);
         $spkiData = SPKIData::getChildrenOfClass($xml);
         $mgmtData = MgmtData::getChildrenOfClass($xml);
+        $derEncodedKeyValue = DEREncodedKeyValue::getChildrenOfClass($xml);
         $other = self::getChildElementsFromXML($xml);
 
         $info = array_merge(
@@ -54,6 +55,7 @@ public static function fromXML(DOMElement $xml): static
             $pgpData,
             $spkiData,
             $mgmtData,
+            $derEncodedKeyValue,
             $other,
         );
 
diff --git a/src/XML/ds/KeyValue.php b/src/XML/ds/KeyValue.php
index 7fba8cc6..01d85e53 100644
--- a/src/XML/ds/KeyValue.php
+++ b/src/XML/ds/KeyValue.php
@@ -6,14 +6,20 @@
 
 use DOMElement;
 use SimpleSAML\Assert\Assert;
-use SimpleSAML\XML\ElementInterface;
+use SimpleSAML\XML\Chunk;
 use SimpleSAML\XML\Exception\InvalidDOMElementException;
 use SimpleSAML\XML\Exception\SchemaViolationException;
 use SimpleSAML\XML\Exception\TooManyElementsException;
 use SimpleSAML\XML\ExtendableElementTrait;
 use SimpleSAML\XML\SchemaValidatableElementInterface;
 use SimpleSAML\XML\SchemaValidatableElementTrait;
+use SimpleSAML\XML\SerializableElementInterface;
 use SimpleSAML\XML\XsNamespace as NS;
+use SimpleSAML\XMLSecurity\Constants as C;
+use SimpleSAML\XMLSecurity\XML\dsig11\ECKeyValue;
+
+use function array_merge;
+use function array_pop;
 
 /**
  * Class representing a ds:KeyValue element.
@@ -22,7 +28,11 @@
  */
 final class KeyValue extends AbstractDsElement implements SchemaValidatableElementInterface
 {
-    use ExtendableElementTrait;
+    // We use our own getter instead of the trait's one, so we prevent their use by marking them private
+    use ExtendableElementTrait {
+        getElements as private;
+        setElements as private;
+    }
     use SchemaValidatableElementTrait;
 
 
@@ -33,21 +43,23 @@ final class KeyValue extends AbstractDsElement implements SchemaValidatableEleme
     /**
      * Initialize an KeyValue.
      *
-     * @param \SimpleSAML\XMLSecurity\XML\ds\RSAKeyValue|null $RSAKeyValue
-     * @param \SimpleSAML\XML\SerializableElementInterface|null $element
+     * @param \SimpleSAML\XML\SerializableElementInterface $keyValue
      */
     final public function __construct(
-        protected ?RSAKeyValue $RSAKeyValue,
-        ?ElementInterface $element = null,
+        protected RSAKeyValue|DSAKeyValue|ECKeyValue|SerializableElementInterface $keyValue,
     ) {
-        Assert::false(
-            is_null($RSAKeyValue) && is_null($element),
-            'A <ds:KeyValue> requires either a RSAKeyValue or an element in namespace ##other',
-            SchemaViolationException::class,
-        );
-
-        if ($element !== null) {
-            $this->setElements([$element]);
+        if (
+            !($keyValue instanceof RSAKeyValue
+            || $keyValue instanceof DSAKeyValue
+            || $keyValue instanceof ECKeyValue)
+        ) {
+            Assert::true(
+                (($keyValue instanceof Chunk) ? $keyValue->getNamespaceURI() : $keyValue::getNameSpaceURI())
+                !== C::NS_XDSIG,
+                'A <ds:KeyValue> requires either a RSAKeyValue, DSAKeyValue, ECKeyValue '
+                . 'or an element in namespace ##other',
+                SchemaViolationException::class,
+            );
         }
     }
 
@@ -55,11 +67,14 @@ final public function __construct(
     /**
      * Collect the value of the RSAKeyValue-property
      *
-     * @return \SimpleSAML\XMLSecurity\XML\ds\RSAKeyValue|null
+     * @return (\SimpleSAML\XMLSecurity\XML\ds\RSAKeyValue|
+     *         \SimpleSAML\XMLSecurity\XML\ds\DSAKeyValue|
+     *         \SimpleSAML\XMLSecurity\XML\dsig11\ECKeyValue|
+     *         \SimpleSAML\XML\SerializableElementInterface)
      */
-    public function getRSAKeyValue(): ?RSAKeyValue
+    public function getKeyValue(): RSAKeyValue|DSAKeyValue|ECKeyValue|SerializableElementInterface
     {
-        return $this->RSAKeyValue;
+        return $this->keyValue;
     }
 
 
@@ -77,23 +92,20 @@ public static function fromXML(DOMElement $xml): static
         Assert::same($xml->localName, 'KeyValue', InvalidDOMElementException::class);
         Assert::same($xml->namespaceURI, KeyValue::NS, InvalidDOMElementException::class);
 
-        $RSAKeyValue = RSAKeyValue::getChildrenOfClass($xml);
-        Assert::maxCount(
-            $RSAKeyValue,
-            1,
-            'A <ds:KeyValue> can contain exactly one <ds:RSAKeyValue>',
-            TooManyElementsException::class,
+        $keyValue = array_merge(
+            RSAKeyValue::getChildrenOfClass($xml),
+            DSAKeyValue::getChildrenOfClass($xml),
+            self::getChildElementsFromXML($xml),
         );
 
-        $elements = self::getChildElementsFromXML($xml);
-        Assert::maxCount(
-            $elements,
+        Assert::count(
+            $keyValue,
             1,
-            'A <ds:KeyValue> can contain exactly one element in namespace ##other',
+            'A <ds:KeyValue> must contain exactly one child element',
             TooManyElementsException::class,
         );
 
-        return new static(array_pop($RSAKeyValue), array_pop($elements));
+        return new static(array_pop($keyValue));
     }
 
 
@@ -107,13 +119,7 @@ public function toXML(?DOMElement $parent = null): DOMElement
     {
         $e = $this->instantiateParentElement($parent);
 
-        $this->getRSAKeyValue()?->toXML($e);
-
-        foreach ($this->elements as $elt) {
-            if (!$elt->isEmptyElement()) {
-                $elt->toXML($e);
-            }
-        }
+        $this->getKeyValue()->toXML($e);
 
         return $e;
     }
diff --git a/src/XML/dsig11/A.php b/src/XML/dsig11/A.php
new file mode 100644
index 00000000..19957519
--- /dev/null
+++ b/src/XML/dsig11/A.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use SimpleSAML\XML\Base64ElementTrait;
+
+/**
+ * Class representing a dsig11:A element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class A extends AbstractDsig11Element
+{
+    use Base64ElementTrait;
+
+
+    /**
+     * Initialize a A element.
+     *
+     * @param string $value
+     */
+    public function __construct(
+        string $value,
+    ) {
+        $this->setContent($value);
+    }
+}
diff --git a/src/XML/dsig11/AbstractCharTwoFieldParamsType.php b/src/XML/dsig11/AbstractCharTwoFieldParamsType.php
new file mode 100644
index 00000000..cb3edacb
--- /dev/null
+++ b/src/XML/dsig11/AbstractCharTwoFieldParamsType.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+
+/**
+ * Abstract class representing a dsig11:CharTwoFieldParamsType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractCharTwoFieldParamsType extends AbstractDsig11Element
+{
+    /**
+     * Initialize a CharTwoFieldParamsType element.
+     *
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\M $m
+     */
+    public function __construct(
+        protected M $m,
+    ) {
+    }
+
+
+    /**
+     * Collect the value of the m-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\M
+     */
+    public function getM(): M
+    {
+        return $this->m;
+    }
+
+
+    /**
+     * Convert this CharTwoFieldParamsType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this CharTwoFieldParamsType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $this->getM()->toXML($e);
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/AbstractCurveType.php b/src/XML/dsig11/AbstractCurveType.php
new file mode 100644
index 00000000..b298a5b9
--- /dev/null
+++ b/src/XML/dsig11/AbstractCurveType.php
@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+
+/**
+ * Abstract class representing a dsig11:CurveType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractCurveType extends AbstractDsig11Element
+{
+    /**
+     * Initialize a CurveType element.
+     *
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\A $a
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\B $b
+     */
+    public function __construct(
+        protected A $a,
+        protected B $b,
+    ) {
+    }
+
+
+    /**
+     * Collect the value of the a-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\A
+     */
+    public function getA(): A
+    {
+        return $this->a;
+    }
+
+
+    /**
+     * Collect the value of the b-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\B
+     */
+    public function getB(): B
+    {
+        return $this->b;
+    }
+
+
+    /**
+     * Convert this CurveType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this CurveType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+
+        $this->getA()->toXML($e);
+        $this->getB()->toXML($e);
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/AbstractECKeyValueType.php b/src/XML/dsig11/AbstractECKeyValueType.php
new file mode 100644
index 00000000..13a65fea
--- /dev/null
+++ b/src/XML/dsig11/AbstractECKeyValueType.php
@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * Abstract class representing a dsig11:ECKeyValueType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractECKeyValueType extends AbstractDsig11Element
+{
+    /**
+     * Initialize a FieldIDType element.
+     *
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\PublicKey $publicKey
+     * @param string|null $id
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\ECParameters|null $ecParameters
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\NamedCurve|null $namedCurve
+     */
+    public function __construct(
+        protected PublicKey $publicKey,
+        protected ?string $id = null,
+        protected ?ECParameters $ecParameters = null,
+        protected ?NamedCurve $namedCurve = null,
+    ) {
+        Assert::validNCName($id, SchemaViolationException::class);
+        Assert::oneOf(
+            null,
+            [$ecParameters, $namedCurve],
+            'The ECParameters and NamedCurve are mutually exclusive; please specify one or the other.',
+            SchemaViolationException::class,
+        );
+    }
+
+
+    /**
+     * Collect the value of the ecParameters-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\ECParameters|null
+     */
+    public function getECParameters(): ?ECParameters
+    {
+        return $this->ecParameters;
+    }
+
+
+    /**
+     * Collect the value of the namedCurve-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\NamedCurve|null
+     */
+    public function getNamedCurve(): ?NamedCurve
+    {
+        return $this->namedCurve;
+    }
+
+
+    /**
+     * Collect the value of the publicKey-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\PublicKey
+     */
+    public function getPublicKey(): PublicKey
+    {
+        return $this->publicKey;
+    }
+
+
+    /**
+     * Collect the value of the id-property
+     *
+     * @return string|null
+     */
+    public function getId(): ?string
+    {
+        return $this->id;
+    }
+
+
+    /**
+     * Convert this ECKeyValueType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this ECKeyValueType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+
+        if ($this->getId() !== null) {
+            $e->setAttribute('Id', $this->getId());
+        }
+
+        $this->getECParameters()?->toXML($e);
+        $this->getNamedCurve()?->toXML($e);
+        $this->getPublicKey()->toXML($e);
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/AbstractECParametersType.php b/src/XML/dsig11/AbstractECParametersType.php
new file mode 100644
index 00000000..b35ca34f
--- /dev/null
+++ b/src/XML/dsig11/AbstractECParametersType.php
@@ -0,0 +1,122 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+
+/**
+ * Abstract class representing a dsig11:ECParametersType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractECParametersType extends AbstractDsig11Element
+{
+    /**
+     * Initialize a ECParametersType element.
+     *
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\FieldID $fieldId
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\Curve $curve
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\Base $base
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\Order $order
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\CoFactor|null $coFactor
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\ValidationData|null $validationData
+     */
+    public function __construct(
+        protected FieldID $fieldId,
+        protected Curve $curve,
+        protected Base $base,
+        protected Order $order,
+        protected ?CoFactor $coFactor = null,
+        protected ?ValidationData $validationData = null,
+    ) {
+    }
+
+
+    /**
+     * Collect the value of the fieldId-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\FieldID
+     */
+    public function getFieldID(): FieldID
+    {
+        return $this->fieldId;
+    }
+
+
+    /**
+     * Collect the value of the curve-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\Curve
+     */
+    public function getCurve(): Curve
+    {
+        return $this->curve;
+    }
+
+
+    /**
+     * Collect the value of the base-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\Base
+     */
+    public function getBase(): Base
+    {
+        return $this->base;
+    }
+
+
+    /**
+     * Collect the value of the order-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\Order
+     */
+    public function getOrder(): Order
+    {
+        return $this->order;
+    }
+
+
+    /**
+     * Collect the value of the coFactor-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\CoFactor|null
+     */
+    public function getCoFactor(): ?CoFactor
+    {
+        return $this->coFactor;
+    }
+
+
+    /**
+     * Collect the value of the validationData-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\ValidationData|null
+     */
+    public function getValidationData(): ?ValidationData
+    {
+        return $this->validationData;
+    }
+
+
+    /**
+     * Convert this ECParametersType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this ECParametersType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+
+        $this->getFieldId()->toXML($e);
+        $this->getCurve()->toXML($e);
+        $this->getBase()->toXML($e);
+        $this->getOrder()->toXML($e);
+        $this->getCoFactor()?->toXML($e);
+        $this->getValidationData()?->toXML($e);
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/AbstractECValidationDataType.php b/src/XML/dsig11/AbstractECValidationDataType.php
new file mode 100644
index 00000000..95d65db2
--- /dev/null
+++ b/src/XML/dsig11/AbstractECValidationDataType.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * Abstract class representing a dsig11:ECValidationDataType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractECValidationDataType extends AbstractDsig11Element
+{
+    /**
+     * Initialize a ECValidationDataType element.
+     *
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\Seed $seed
+     * @param string $hashAlgorithm
+     */
+    public function __construct(
+        protected Seed $seed,
+        protected string $hashAlgorithm,
+    ) {
+        Assert::validURI($hashAlgorithm, SchemaViolationException::class);
+    }
+
+
+    /**
+     * Collect the value of the seed-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\Seed
+     */
+    public function getSeed(): Seed
+    {
+        return $this->seed;
+    }
+
+
+    /**
+     * Collect the value of the hashAlgorithm-property
+     *
+     * @return string
+     */
+    public function getHashAlgorithm(): string
+    {
+        return $this->hashAlgorithm;
+    }
+
+
+    /**
+     * Convert this ECValidationDataType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this ECValidationDataType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $e->setAttribute('hashAlgorithm', $this->getHashAlgorithm());
+
+        $this->getSeed()->toXML($e);
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/AbstractFieldIDType.php b/src/XML/dsig11/AbstractFieldIDType.php
new file mode 100644
index 00000000..cc15ede9
--- /dev/null
+++ b/src/XML/dsig11/AbstractFieldIDType.php
@@ -0,0 +1,86 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Chunk;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\ExtendableElementTrait;
+use SimpleSAML\XML\SerializableElementInterface;
+use SimpleSAML\XML\XsNamespace as NS;
+use SimpleSAML\XMLSecurity\Constants as C;
+
+/**
+ * Abstract class representing a dsig11:FieldIDType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractFieldIDType extends AbstractDsig11Element
+{
+    // We use our own getter instead of the trait's one, so we prevent their use by marking them private
+    use ExtendableElementTrait {
+        getElements as private;
+        setElements as private;
+    }
+
+    /** @var \SimpleSAML\XML\XsNamespace */
+    public const XS_ANY_ELT_NAMESPACE = NS::OTHER;
+
+
+    /**
+     * Initialize a FieldIDType element.
+     *
+     * @param \SimpleSAML\XML\SerializableElementInterface $fieldId
+     */
+    public function __construct(
+        protected Prime|TnB|PnB|GnB|SerializableElementInterface $fieldId,
+    ) {
+        if (
+            !($fieldId instanceof Prime
+            || $fieldId instanceof TnB
+            || $fieldId instanceof PnB
+            || $fieldId instanceof GnB)
+        ) {
+            Assert::true(
+                (($fieldId instanceof Chunk) ? $fieldId->getNamespaceURI() : $fieldId::getNameSpaceURI())
+                !== C::NS_XDSIG11,
+                'A <dsig11:FieldIDType> requires either a Prime, TnB, PnB, GnB or an element in namespace ##other',
+                SchemaViolationException::class,
+            );
+        }
+    }
+
+
+    /**
+     * Collect the value of the fieldId-property
+     *
+     * @return (\SimpleSAML\XMLSecurity\XML\dsig11\Prime|
+     *         \SimpleSAML\XMLSecurity\XML\dsig11\TnB|
+     *         \SimpleSAML\XMLSecurity\XML\dsig11\PnB|
+     *         \SimpleSAML\XMLSecurity\XML\dsig11\GnB|
+     *         \SimpleSAML\XML\SerializableElementInterface)
+     */
+    public function getFieldId(): Prime|TnB|PnB|GnB|SerializableElementInterface
+    {
+        return $this->fieldId;
+    }
+
+
+    /**
+     * Convert this FieldIDType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this FieldIDType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+
+        $this->getFieldId()->toXML($e);
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/AbstractNamedCurveType.php b/src/XML/dsig11/AbstractNamedCurveType.php
new file mode 100644
index 00000000..a01ab586
--- /dev/null
+++ b/src/XML/dsig11/AbstractNamedCurveType.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * Abstract class representing a dsig11:NamedCurveType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractNamedCurveType extends AbstractDsig11Element
+{
+    /**
+     * Initialize a NamedCurveType element.
+     *
+     * @param string $URI
+     */
+    public function __construct(
+        protected string $URI,
+    ) {
+        Assert::validURI($URI, SchemaViolationException::class);
+    }
+
+
+    /**
+     * Collect the value of the URI-property
+     *
+     * @return string
+     */
+    public function getURI(): string
+    {
+        return $this->URI;
+    }
+
+
+    /**
+     * Convert this NamedCurveType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this NamedCurveType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $e->setAttribute('URI', $this->getURI());
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/AbstractPnBFieldParamsType.php b/src/XML/dsig11/AbstractPnBFieldParamsType.php
new file mode 100644
index 00000000..e0d1dede
--- /dev/null
+++ b/src/XML/dsig11/AbstractPnBFieldParamsType.php
@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+
+/**
+ * Abstract class representing a dsig11:PnBFieldParamsType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractPnBFieldParamsType extends AbstractCharTwoFieldParamsType
+{
+    /**
+     * Initialize a PnBFieldParamsType element.
+     *
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\M $m
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\K1 $k1
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\K2 $k2
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\K3 $k3
+     */
+    public function __construct(
+        M $m,
+        protected K1 $k1,
+        protected K2 $k2,
+        protected K3 $k3,
+    ) {
+        parent::__construct($m);
+    }
+
+
+    /**
+     * Collect the value of the k1-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\K1
+     */
+    public function getK1(): K1
+    {
+        return $this->k1;
+    }
+
+
+    /**
+     * Collect the value of the k2-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\K2
+     */
+    public function getK2(): K2
+    {
+        return $this->k2;
+    }
+
+
+    /**
+     * Collect the value of the k3-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\K3
+     */
+    public function getK3(): K3
+    {
+        return $this->k3;
+    }
+
+
+    /**
+     * Convert this PnBFieldParamsType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this PnBFieldParamsType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = parent::toXML($parent);
+        $this->getK1()->toXML($e);
+        $this->getK2()->toXML($e);
+        $this->getK3()->toXML($e);
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/AbstractPrimeFieldParamsType.php b/src/XML/dsig11/AbstractPrimeFieldParamsType.php
new file mode 100644
index 00000000..8a1ac69b
--- /dev/null
+++ b/src/XML/dsig11/AbstractPrimeFieldParamsType.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+
+/**
+ * Abstract class representing a dsig11:PrimeFieldParamsType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractPrimeFieldParamsType extends AbstractDsig11Element
+{
+    /**
+     * Initialize a PrimeFieldParamsType element.
+     *
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\P $p
+     */
+    public function __construct(
+        protected P $p,
+    ) {
+    }
+
+
+    /**
+     * Collect the value of the p-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\P
+     */
+    public function getP(): P
+    {
+        return $this->p;
+    }
+
+
+    /**
+     * Convert this PrimeFieldParamsType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this PrimeFieldParamsType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $this->getP()->toXML($e);
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/AbstractTnBFieldParamsType.php b/src/XML/dsig11/AbstractTnBFieldParamsType.php
new file mode 100644
index 00000000..11171478
--- /dev/null
+++ b/src/XML/dsig11/AbstractTnBFieldParamsType.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+
+/**
+ * Abstract class representing a dsig11:TnBFieldParamsType
+ *
+ * @package simplesaml/xml-security
+ */
+abstract class AbstractTnBFieldParamsType extends AbstractCharTwoFieldParamsType
+{
+    /**
+     * Initialize a TnBFieldParamsType element.
+     *
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\M $m
+     * @param \SimpleSAML\XMLSecurity\XML\dsig11\K $k
+     */
+    public function __construct(
+        M $m,
+        protected K $k,
+    ) {
+        parent::__construct($m);
+    }
+
+
+    /**
+     * Collect the value of the k-property
+     *
+     * @return \SimpleSAML\XMLSecurity\XML\dsig11\K
+     */
+    public function getK(): K
+    {
+        return $this->k;
+    }
+
+
+    /**
+     * Convert this TnBFieldParamsType element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this TnBFieldParamsType element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = parent::toXML($parent);
+        $this->getK()->toXML($e);
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/B.php b/src/XML/dsig11/B.php
new file mode 100644
index 00000000..38c39c4e
--- /dev/null
+++ b/src/XML/dsig11/B.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use SimpleSAML\XML\Base64ElementTrait;
+
+/**
+ * Class representing a dsig11:B element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class B extends AbstractDsig11Element
+{
+    use Base64ElementTrait;
+
+
+    /**
+     * Initialize a B element.
+     *
+     * @param string $value
+     */
+    public function __construct(
+        string $value,
+    ) {
+        $this->setContent($value);
+    }
+}
diff --git a/src/XML/dsig11/Base.php b/src/XML/dsig11/Base.php
new file mode 100644
index 00000000..15bf664f
--- /dev/null
+++ b/src/XML/dsig11/Base.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use SimpleSAML\XML\Base64ElementTrait;
+
+/**
+ * Class representing a dsig11:Base element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class Base extends AbstractDsig11Element
+{
+    use Base64ElementTrait;
+
+
+    /**
+     * Initialize a Base element.
+     *
+     * @param string $value
+     */
+    public function __construct(
+        string $value,
+    ) {
+        $this->setContent($value);
+    }
+}
diff --git a/src/XML/dsig11/CoFactor.php b/src/XML/dsig11/CoFactor.php
new file mode 100644
index 00000000..c1741c6e
--- /dev/null
+++ b/src/XML/dsig11/CoFactor.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+use function intval;
+use function strval;
+
+/**
+ * Class representing a dsig11:CoFactor element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class CoFactor extends AbstractDsig11Element
+{
+    /**
+     * @param int $value
+     */
+    public function __construct(
+        protected int $value,
+    ) {
+        Assert::positiveInteger($value, SchemaViolationException::class);
+    }
+
+
+    /**
+     * @return int
+     */
+    public function getValue(): int
+    {
+        return $this->value;
+    }
+
+
+    /**
+     * Convert XML into a class instance
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::NS, InvalidDOMElementException::class);
+        Assert::numeric($xml->textContent);
+
+        return new static(intval($xml->textContent));
+    }
+
+
+    /**
+     * Convert this element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $e->textContent = strval($this->getValue());
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/Curve.php b/src/XML/dsig11/Curve.php
new file mode 100644
index 00000000..8879754f
--- /dev/null
+++ b/src/XML/dsig11/Curve.php
@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\MissingElementException;
+use SimpleSAML\XML\Exception\TooManyElementsException;
+use SimpleSAML\XMLSecurity\XML\dsig11\A;
+use SimpleSAML\XMLSecurity\XML\dsig11\B;
+
+/**
+ * Class representing a dsig11:Curve element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class Curve extends AbstractCurveType
+{
+    /**
+     * Convert XML into a class instance
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::NS, InvalidDOMElementException::class);
+
+        $a = A::getChildrenOfClass($xml);
+        Assert::minCount($a, 1, MissingElementException::class);
+        Assert::maxCount($a, 1, TooManyElementsException::class);
+
+        $b = B::getChildrenOfClass($xml);
+        Assert::minCount($b, 1, MissingElementException::class);
+        Assert::maxCount($b, 1, TooManyElementsException::class);
+
+        return new static(
+            array_pop($a),
+            array_pop($b),
+        );
+    }
+}
diff --git a/src/XML/dsig11/DEREncodedKeyValue.php b/src/XML/dsig11/DEREncodedKeyValue.php
new file mode 100644
index 00000000..f3bbe1c2
--- /dev/null
+++ b/src/XML/dsig11/DEREncodedKeyValue.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\XML\Assert\Assert;
+use SimpleSAML\XML\Base64ElementTrait;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+use SimpleSAML\XML\SchemaValidatableElementInterface;
+use SimpleSAML\XML\SchemaValidatableElementTrait;
+
+/**
+ * Class representing a dsig11:DEREncodedKeyValue element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class DEREncodedKeyValue extends AbstractDsig11Element implements SchemaValidatableElementInterface
+{
+    use Base64ElementTrait;
+    use SchemaValidatableElementTrait;
+
+
+    /**
+     * Initialize a DEREncodedKeyValue element.
+     *
+     * @param string $value
+     * @param string|null $Id
+     */
+    public function __construct(
+        string $value,
+        protected ?string $Id = null,
+    ) {
+        Assert::validNCName($Id, SchemaViolationException::class);
+
+        $this->setContent($value);
+    }
+
+
+    /**
+     * Collect the value of the Id-property
+     *
+     * @return string|null
+     */
+    public function getId(): ?string
+    {
+        return $this->Id;
+    }
+
+
+    /**
+     * Convert XML into a DEREncodedKeyValue
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        return new static(
+            $xml->textContent,
+            self::getOptionalAttribute($xml, 'Id', null),
+        );
+    }
+
+
+    /**
+     * Convert this DEREncodedKeyValue element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this DEREncodedKeyValue element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $e->textContent = $this->getContent();
+
+        if ($this->getId() !== null) {
+            $e->setAttribute('Id', $this->getId());
+        }
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/ECKeyValue.php b/src/XML/dsig11/ECKeyValue.php
new file mode 100644
index 00000000..c4d78437
--- /dev/null
+++ b/src/XML/dsig11/ECKeyValue.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\MissingElementException;
+use SimpleSAML\XML\Exception\TooManyElementsException;
+use SimpleSAML\XML\SchemaValidatableElementInterface;
+use SimpleSAML\XML\SchemaValidatableElementTrait;
+
+use function array_pop;
+
+/**
+ * Class representing a dsig11:ECKeyValue element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class ECKeyValue extends AbstractECKeyValueType implements SchemaValidatableElementInterface
+{
+    use SchemaValidatableElementTrait;
+
+    /**
+     * Convert XML into a ECKeyValue element
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        $publicKey = PublicKey::getChildrenOfClass($xml);
+        Assert::minCount($publicKey, 1, MissingElementException::class);
+        Assert::maxCount($publicKey, 1, TooManyElementsException::class);
+
+        $ecParameters = ECParameters::getChildrenOfClass($xml);
+        Assert::maxCount($ecParameters, 1, TooManyElementsException::class);
+
+        $namedCurve = NamedCurve::getChildrenOfClass($xml);
+        Assert::maxCount($namedCurve, 1, TooManyElementsException::class);
+
+        return new static(
+            array_pop($publicKey),
+            self::getOptionalAttribute($xml, 'Id', null),
+            array_pop($ecParameters),
+            array_pop($namedCurve),
+        );
+    }
+}
diff --git a/src/XML/dsig11/ECParameters.php b/src/XML/dsig11/ECParameters.php
new file mode 100644
index 00000000..dee70308
--- /dev/null
+++ b/src/XML/dsig11/ECParameters.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\MissingElementException;
+use SimpleSAML\XML\Exception\TooManyElementsException;
+
+use function array_pop;
+
+/**
+ * Class representing a dsig11:ECParameters element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class ECParameters extends AbstractECParametersType
+{
+    /**
+     * Convert XML into a ECParameters element
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        $fieldId = FieldID::getChildrenOfClass($xml);
+        Assert::minCount($fieldId, 1, MissingElementException::class);
+        Assert::maxCount($fieldId, 1, TooManyElementsException::class);
+
+        $curve = Curve::getChildrenOfClass($xml);
+        Assert::minCount($curve, 1, MissingElementException::class);
+        Assert::maxCount($curve, 1, TooManyElementsException::class);
+
+        $base = Base::getChildrenOfClass($xml);
+        Assert::minCount($base, 1, MissingElementException::class);
+        Assert::maxCount($base, 1, TooManyElementsException::class);
+
+        $order = Order::getChildrenOfClass($xml);
+        Assert::minCount($order, 1, MissingElementException::class);
+        Assert::maxCount($order, 1, TooManyElementsException::class);
+
+        $coFactor = CoFactor::getChildrenOfClass($xml);
+        Assert::maxCount($coFactor, 1, TooManyElementsException::class);
+
+        $validationData = ValidationData::getChildrenOfClass($xml);
+        Assert::maxCount($validationData, 1, TooManyElementsException::class);
+
+        return new static(
+            array_pop($fieldId),
+            array_pop($curve),
+            array_pop($base),
+            array_pop($order),
+            array_pop($coFactor),
+            array_pop($validationData),
+        );
+    }
+}
diff --git a/src/XML/dsig11/FieldID.php b/src/XML/dsig11/FieldID.php
new file mode 100644
index 00000000..0b431c71
--- /dev/null
+++ b/src/XML/dsig11/FieldID.php
@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\TooManyElementsException;
+use SimpleSAML\XML\SchemaValidatableElementInterface;
+use SimpleSAML\XML\SchemaValidatableElementTrait;
+
+/**
+ * Class representing a dsig11:FieldID element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class FieldID extends AbstractFieldIDType implements SchemaValidatableElementInterface
+{
+    use SchemaValidatableElementTrait;
+
+    /**
+     * Convert XML into a FieldID element
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        $fieldId = array_merge(
+            Prime::getChildrenOfClass($xml),
+            TnB::getChildrenOfClass($xml),
+            PnB::getChildrenOfClass($xml),
+            GnB::getChildrenOfClass($xml),
+            self::getChildElementsFromXML($xml),
+        );
+
+        Assert::count(
+            $fieldId,
+            1,
+            'A <dsig11:FieldID> must contain exactly one child element',
+            TooManyElementsException::class,
+        );
+
+        return new static(
+            array_pop($fieldId),
+        );
+    }
+}
diff --git a/src/XML/dsig11/GnB.php b/src/XML/dsig11/GnB.php
new file mode 100644
index 00000000..196fe47e
--- /dev/null
+++ b/src/XML/dsig11/GnB.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\MissingElementException;
+use SimpleSAML\XML\Exception\TooManyElementsException;
+use SimpleSAML\XML\SchemaValidatableElementInterface;
+use SimpleSAML\XML\SchemaValidatableElementTrait;
+
+use function array_pop;
+
+/**
+ * Class representing a dsig11:GnB element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class GnB extends AbstractCharTwoFieldParamsType implements SchemaValidatableElementInterface
+{
+    use SchemaValidatableElementTrait;
+
+    /**
+     * Convert XML into a GnB element
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        $m = M::getChildrenOfClass($xml);
+        Assert::minCount($m, 1, MissingElementException::class);
+        Assert::maxCount($m, 1, TooManyElementsException::class);
+
+        return new static(
+            array_pop($m),
+        );
+    }
+}
diff --git a/src/XML/dsig11/K.php b/src/XML/dsig11/K.php
new file mode 100644
index 00000000..7bf3cac6
--- /dev/null
+++ b/src/XML/dsig11/K.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * Class representing a dsig11:K element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class K extends AbstractDsig11Element
+{
+    /**
+     * @param int $k
+     */
+    public function __construct(
+        protected int $k,
+    ) {
+        Assert::positiveInteger($k, SchemaViolationException::class);
+    }
+
+
+    /**
+     * @return int
+     */
+    public function getK(): int
+    {
+        return $this->k;
+    }
+
+
+    /**
+     * Convert XML into a class instance
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::NS, InvalidDOMElementException::class);
+        Assert::numeric($xml->textContent);
+
+        return new static(intval($xml->textContent));
+    }
+
+
+    /**
+     * Convert this element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $e->textContent = strval($this->getK());
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/K1.php b/src/XML/dsig11/K1.php
new file mode 100644
index 00000000..51364a78
--- /dev/null
+++ b/src/XML/dsig11/K1.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * Class representing a dsig11:K1 element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class K1 extends AbstractDsig11Element
+{
+    /**
+     * @param int $k1
+     */
+    public function __construct(
+        protected int $k1,
+    ) {
+        Assert::positiveInteger($k1, SchemaViolationException::class);
+    }
+
+
+    /**
+     * @return int
+     */
+    public function getK1(): int
+    {
+        return $this->k1;
+    }
+
+
+    /**
+     * Convert XML into a class instance
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::NS, InvalidDOMElementException::class);
+        Assert::numeric($xml->textContent);
+
+        return new static(intval($xml->textContent));
+    }
+
+
+    /**
+     * Convert this element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $e->textContent = strval($this->getK1());
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/K2.php b/src/XML/dsig11/K2.php
new file mode 100644
index 00000000..8cb56613
--- /dev/null
+++ b/src/XML/dsig11/K2.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * Class representing a dsig11:K2 element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class K2 extends AbstractDsig11Element
+{
+    /**
+     * @param int $k2
+     */
+    public function __construct(
+        protected int $k2,
+    ) {
+        Assert::positiveInteger($k2, SchemaViolationException::class);
+    }
+
+
+    /**
+     * @return int
+     */
+    public function getK2(): int
+    {
+        return $this->k2;
+    }
+
+
+    /**
+     * Convert XML into a class instance
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::NS, InvalidDOMElementException::class);
+        Assert::numeric($xml->textContent);
+
+        return new static(intval($xml->textContent));
+    }
+
+
+    /**
+     * Convert this element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $e->textContent = strval($this->getK2());
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/K3.php b/src/XML/dsig11/K3.php
new file mode 100644
index 00000000..9cf92713
--- /dev/null
+++ b/src/XML/dsig11/K3.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * Class representing a dsig11:K3 element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class K3 extends AbstractDsig11Element
+{
+    /**
+     * @param int $k3
+     */
+    public function __construct(
+        protected int $k3,
+    ) {
+        Assert::positiveInteger($k3, SchemaViolationException::class);
+    }
+
+
+    /**
+     * @return int
+     */
+    public function getK3(): int
+    {
+        return $this->k3;
+    }
+
+
+    /**
+     * Convert XML into a class instance
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::NS, InvalidDOMElementException::class);
+        Assert::numeric($xml->textContent);
+
+        return new static(intval($xml->textContent));
+    }
+
+
+    /**
+     * Convert this element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $e->textContent = strval($this->getK3());
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/M.php b/src/XML/dsig11/M.php
new file mode 100644
index 00000000..ec429082
--- /dev/null
+++ b/src/XML/dsig11/M.php
@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\SchemaViolationException;
+
+/**
+ * Class representing a dsig11:M element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class M extends AbstractDsig11Element
+{
+    /**
+     * @param int $m
+     */
+    public function __construct(
+        protected int $m,
+    ) {
+        Assert::positiveInteger($m, SchemaViolationException::class);
+    }
+
+
+    /**
+     * @return int
+     */
+    public function getM(): int
+    {
+        return $this->m;
+    }
+
+
+    /**
+     * Convert XML into a class instance
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::NS, InvalidDOMElementException::class);
+        Assert::numeric($xml->textContent);
+
+        return new static(intval($xml->textContent));
+    }
+
+
+    /**
+     * Convert this element to XML.
+     *
+     * @param \DOMElement|null $parent The element we should append this element to.
+     * @return \DOMElement
+     */
+    public function toXML(?DOMElement $parent = null): DOMElement
+    {
+        $e = $this->instantiateParentElement($parent);
+        $e->textContent = strval($this->getM());
+
+        return $e;
+    }
+}
diff --git a/src/XML/dsig11/NamedCurve.php b/src/XML/dsig11/NamedCurve.php
new file mode 100644
index 00000000..fdf23490
--- /dev/null
+++ b/src/XML/dsig11/NamedCurve.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+
+/**
+ * Class representing a dsig11:NamedCurve element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class NamedCurve extends AbstractNamedCurveType
+{
+    /**
+     * Convert XML into a NamedCurve element
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        return new static(
+            self::getAttribute($xml, 'URI'),
+        );
+    }
+}
diff --git a/src/XML/dsig11/Order.php b/src/XML/dsig11/Order.php
new file mode 100644
index 00000000..d803acec
--- /dev/null
+++ b/src/XML/dsig11/Order.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use SimpleSAML\XML\Base64ElementTrait;
+
+/**
+ * Class representing a dsig11:Order element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class Order extends AbstractDsig11Element
+{
+    use Base64ElementTrait;
+
+
+    /**
+     * Initialize a Order element.
+     *
+     * @param string $value
+     */
+    public function __construct(
+        string $value,
+    ) {
+        $this->setContent($value);
+    }
+}
diff --git a/src/XML/dsig11/P.php b/src/XML/dsig11/P.php
new file mode 100644
index 00000000..ea807ea2
--- /dev/null
+++ b/src/XML/dsig11/P.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use SimpleSAML\XML\Base64ElementTrait;
+
+/**
+ * Class representing a dsig11:P element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class P extends AbstractDsig11Element
+{
+    use Base64ElementTrait;
+
+
+    /**
+     * Initialize a P element.
+     *
+     * @param string $value
+     */
+    public function __construct(
+        string $value,
+    ) {
+        $this->setContent($value);
+    }
+}
diff --git a/src/XML/dsig11/PnB.php b/src/XML/dsig11/PnB.php
new file mode 100644
index 00000000..71894e2f
--- /dev/null
+++ b/src/XML/dsig11/PnB.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\MissingElementException;
+use SimpleSAML\XML\Exception\TooManyElementsException;
+use SimpleSAML\XML\SchemaValidatableElementInterface;
+use SimpleSAML\XML\SchemaValidatableElementTrait;
+
+use function array_pop;
+
+/**
+ * Class representing a dsig11:PnB element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class PnB extends AbstractPnBFieldParamsType implements SchemaValidatableElementInterface
+{
+    use SchemaValidatableElementTrait;
+
+    /**
+     * Convert XML into a PnB element
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        $k1 = K1::getChildrenOfClass($xml);
+        Assert::minCount($k1, 1, MissingElementException::class);
+        Assert::maxCount($k1, 1, TooManyElementsException::class);
+
+        $k2 = K2::getChildrenOfClass($xml);
+        Assert::minCount($k2, 1, MissingElementException::class);
+        Assert::maxCount($k2, 1, TooManyElementsException::class);
+
+        $k3 = K3::getChildrenOfClass($xml);
+        Assert::minCount($k3, 1, MissingElementException::class);
+        Assert::maxCount($k3, 1, TooManyElementsException::class);
+
+        $m = M::getChildrenOfClass($xml);
+        Assert::minCount($m, 1, MissingElementException::class);
+        Assert::maxCount($m, 1, TooManyElementsException::class);
+
+        return new static(
+            array_pop($m),
+            array_pop($k1),
+            array_pop($k2),
+            array_pop($k3),
+        );
+    }
+}
diff --git a/src/XML/dsig11/Prime.php b/src/XML/dsig11/Prime.php
new file mode 100644
index 00000000..ec5b0af0
--- /dev/null
+++ b/src/XML/dsig11/Prime.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\MissingElementException;
+use SimpleSAML\XML\Exception\TooManyElementsException;
+use SimpleSAML\XML\SchemaValidatableElementInterface;
+use SimpleSAML\XML\SchemaValidatableElementTrait;
+
+use function array_pop;
+
+/**
+ * Class representing a dsig11:Prime element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class Prime extends AbstractPrimeFieldParamsType implements SchemaValidatableElementInterface
+{
+    use SchemaValidatableElementTrait;
+
+    /**
+     * Convert XML into a Prime element
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        $p = P::getChildrenOfClass($xml);
+        Assert::minCount($p, 1, MissingElementException::class);
+        Assert::maxCount($p, 1, TooManyElementsException::class);
+
+        return new static(
+            array_pop($p),
+        );
+    }
+}
diff --git a/src/XML/dsig11/PublicKey.php b/src/XML/dsig11/PublicKey.php
new file mode 100644
index 00000000..bf8bf1a5
--- /dev/null
+++ b/src/XML/dsig11/PublicKey.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use SimpleSAML\XML\Base64ElementTrait;
+
+/**
+ * Class representing a dsig11:PublicKey element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class PublicKey extends AbstractDsig11Element
+{
+    use Base64ElementTrait;
+
+
+    /**
+     * Initialize a PublicKey element.
+     *
+     * @param string $value
+     */
+    public function __construct(
+        string $value,
+    ) {
+        $this->setContent($value);
+    }
+}
diff --git a/src/XML/dsig11/Seed.php b/src/XML/dsig11/Seed.php
new file mode 100644
index 00000000..fda47836
--- /dev/null
+++ b/src/XML/dsig11/Seed.php
@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use SimpleSAML\XML\Base64ElementTrait;
+
+/**
+ * Class representing a dsig11:Seed element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class Seed extends AbstractDsig11Element
+{
+    use Base64ElementTrait;
+
+    /** @var string */
+    public const LOCALNAME = 'seed';
+
+
+    /**
+     * Initialize a Seed element.
+     *
+     * @param string $value
+     */
+    public function __construct(
+        string $value,
+    ) {
+        $this->setContent($value);
+    }
+}
diff --git a/src/XML/dsig11/TnB.php b/src/XML/dsig11/TnB.php
new file mode 100644
index 00000000..7f4b2e9c
--- /dev/null
+++ b/src/XML/dsig11/TnB.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\MissingElementException;
+use SimpleSAML\XML\Exception\TooManyElementsException;
+use SimpleSAML\XML\SchemaValidatableElementInterface;
+use SimpleSAML\XML\SchemaValidatableElementTrait;
+
+use function array_pop;
+
+/**
+ * Class representing a dsig11:TnB element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class TnB extends AbstractTnBFieldParamsType implements SchemaValidatableElementInterface
+{
+    use SchemaValidatableElementTrait;
+
+    /**
+     * Convert XML into a TnB element
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        $k = K::getChildrenOfClass($xml);
+        Assert::minCount($k, 1, MissingElementException::class);
+        Assert::maxCount($k, 1, TooManyElementsException::class);
+
+        $m = M::getChildrenOfClass($xml);
+        Assert::minCount($m, 1, MissingElementException::class);
+        Assert::maxCount($m, 1, TooManyElementsException::class);
+
+        return new static(
+            array_pop($m),
+            array_pop($k),
+        );
+    }
+}
diff --git a/src/XML/dsig11/ValidationData.php b/src/XML/dsig11/ValidationData.php
new file mode 100644
index 00000000..20cf4c0a
--- /dev/null
+++ b/src/XML/dsig11/ValidationData.php
@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\XML\dsig11;
+
+use DOMElement;
+use SimpleSAML\Assert\Assert;
+use SimpleSAML\XML\Exception\InvalidDOMElementException;
+use SimpleSAML\XML\Exception\MissingElementException;
+use SimpleSAML\XML\Exception\TooManyElementsException;
+use SimpleSAML\XML\SchemaValidatableElementInterface;
+use SimpleSAML\XML\SchemaValidatableElementTrait;
+
+use function array_pop;
+
+/**
+ * Class representing a dsig11:ValidationData element.
+ *
+ * @package simplesaml/xml-security
+ */
+final class ValidationData extends AbstractECValidationDataType implements SchemaValidatableElementInterface
+{
+    use SchemaValidatableElementTrait;
+
+    /**
+     * Convert XML into a ValidationData element
+     *
+     * @param \DOMElement $xml The XML element we should load
+     * @return static
+     *
+     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
+     *   If the qualified name of the supplied element is wrong
+     */
+    public static function fromXML(DOMElement $xml): static
+    {
+        Assert::same($xml->localName, static::getLocalName(), InvalidDOMElementException::class);
+        Assert::same($xml->namespaceURI, static::getNamespaceURI(), InvalidDOMElementException::class);
+
+        $seed = Seed::getChildrenOfClass($xml);
+        Assert::minCount($seed, 1, MissingElementException::class);
+        Assert::maxCount($seed, 1, TooManyElementsException::class);
+
+        return new static(
+            array_pop($seed),
+            self::getAttribute($xml, 'hashAlgorithm'),
+        );
+    }
+}
diff --git a/src/XML/element.registry.php b/src/XML/element.registry.php
index 82e5b59d..495adbd6 100644
--- a/src/XML/element.registry.php
+++ b/src/XML/element.registry.php
@@ -30,7 +30,7 @@
         'X509Data' => '\SimpleSAML\XMLSecurity\XML\ds\X509Data',
     ],
     'http://www.w3.org/2009/xmldsig11#' => [
-//        'DEREncodedKeyValue' => '\SimpleSAML\XMLSecurity\XML\dsig11\DEREncodedKeyValue',
+        'DEREncodedKeyValue' => '\SimpleSAML\XMLSecurity\XML\dsig11\DEREncodedKeyValue',
 //        'ECKeyValue' => '\SimpleSAML\XMLSecurity\XML\dsig11\ECKeyValue',
 //        'GnB' => '\SimpleSAML\XMLSecurity\XML\dsig11\GnB',
         'KeyInfoReference' => '\SimpleSAML\XMLSecurity\XML\dsig11\KeyInfoReference',
diff --git a/tests/XML/ds/KeyValueTest.php b/tests/XML/ds/KeyValueTest.php
index da3f9695..0c9f1cfc 100644
--- a/tests/XML/ds/KeyValueTest.php
+++ b/tests/XML/ds/KeyValueTest.php
@@ -70,9 +70,8 @@ public function testMarshalling(): void
     {
         $keyValue = new KeyValue(RSAKeyValue::fromXML(self::$rsaKeyValue->documentElement));
 
-        $rsaKeyValue = $keyValue->getRSAKeyValue();
+        $rsaKeyValue = $keyValue->getKeyValue();
         $this->assertInstanceOf(RSAKeyValue::class, $rsaKeyValue);
-        $this->assertEmpty($keyValue->getElements());
 
         $this->assertEquals($rsaKeyValue->getModulus()->getContent(), 'dGhpcyBpcyBzb21lIHJhbmRvbSBtb2R1bHVzCg==');
         $this->assertEquals($rsaKeyValue->getExponent()->getContent(), 'dGhpcyBpcyBzb21lIHJhbmRvbSBleHBvbmVudAo=');
@@ -88,13 +87,9 @@ public function testMarshalling(): void
      */
     public function testMarshallingWithOtherElement(): void
     {
-        $keyValue = new KeyValue(null, EncryptionProperty::fromXML(self::$encryptionProperty->documentElement));
+        $keyValue = new KeyValue(EncryptionProperty::fromXML(self::$encryptionProperty->documentElement));
 
-        $elements = $keyValue->getElements();
-        $this->assertEmpty($keyValue->getRSAKeyValue());
-        $this->assertCount(1, $elements);
-
-        $element = reset($elements);
+        $element = $keyValue->getKeyValue();
         $this->assertInstanceOf(EncryptionProperty::class, $element);
 
         $document = self::$empty;
@@ -104,19 +99,6 @@ public function testMarshallingWithOtherElement(): void
     }
 
 
-    /**
-     */
-    public function testMarshallingEmpty(): void
-    {
-        $this->expectException(SchemaViolationException::class);
-        $this->expectExceptionMessage(
-            'A <ds:KeyValue> requires either a RSAKeyValue or an element in namespace ##other',
-        );
-
-        new KeyValue(null, null);
-    }
-
-
     /**
      */
     public function testUnmarshallingWithOtherElement(): void
@@ -128,11 +110,7 @@ public function testUnmarshallingWithOtherElement(): void
 
         $keyValue = KeyValue::fromXML($document->documentElement);
 
-        $elements = $keyValue->getElements();
-        $this->assertNull($keyValue->getRSAKeyValue());
-        $this->assertCount(1, $elements);
-
-        $element = reset($elements);
+        $element = $keyValue->getKeyValue();
         $this->assertInstanceOf(EncryptionProperty::class, $element);
     }
 
@@ -145,7 +123,7 @@ public function testUnmarshallingEmpty(): void
 
         $this->expectException(SchemaViolationException::class);
         $this->expectExceptionMessage(
-            'A <ds:KeyValue> requires either a RSAKeyValue or an element in namespace ##other',
+            'A <ds:KeyValue> must contain exactly one child element',
         );
 
         KeyValue::fromXML($document->documentElement);
diff --git a/tests/XML/dsig11/ATest.php b/tests/XML/dsig11/ATest.php
new file mode 100644
index 00000000..b8f68c03
--- /dev/null
+++ b/tests/XML/dsig11/ATest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Test\XML\XMLDumper;
+use SimpleSAML\XMLSecurity\XML\dsig11\A;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\ATest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(A::class)]
+final class ATest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = A::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_A.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $a = new A('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        $this->assertEquals(
+            XMLDumper::dumpDOMDocumentXMLWithBase64Content(self::$xmlRepresentation),
+            strval($a),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/BTest.php b/tests/XML/dsig11/BTest.php
new file mode 100644
index 00000000..5d5374e8
--- /dev/null
+++ b/tests/XML/dsig11/BTest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Test\XML\XMLDumper;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\B;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\BTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(B::class)]
+final class BTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = B::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_B.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $b = new B('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        $this->assertEquals(
+            XMLDumper::dumpDOMDocumentXMLWithBase64Content(self::$xmlRepresentation),
+            strval($b),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/BaseTest.php b/tests/XML/dsig11/BaseTest.php
new file mode 100644
index 00000000..29d2977e
--- /dev/null
+++ b/tests/XML/dsig11/BaseTest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Test\XML\XMLDumper;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\Base;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\BaseTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(Base::class)]
+final class BaseTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = Base::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_Base.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $base = new Base('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        $this->assertEquals(
+            XMLDumper::dumpDOMDocumentXMLWithBase64Content(self::$xmlRepresentation),
+            strval($base),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/CoFactorTest.php b/tests/XML/dsig11/CoFactorTest.php
new file mode 100644
index 00000000..4c698aad
--- /dev/null
+++ b/tests/XML/dsig11/CoFactorTest.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\CoFactor;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\CoFactorTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(CoFactor::class)]
+final class CoFactorTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = CoFactor::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_CoFactor.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $coFactor = new CoFactor(128);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($coFactor),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/CurveTest.php b/tests/XML/dsig11/CurveTest.php
new file mode 100644
index 00000000..0914cb37
--- /dev/null
+++ b/tests/XML/dsig11/CurveTest.php
@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\A;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractCurveType;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\B;
+use SimpleSAML\XMLSecurity\XML\dsig11\Curve;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\CurveTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractCurveType::class)]
+#[CoversClass(Curve::class)]
+final class CurveTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = Curve::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_Curve.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $a = new A('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $b = new B('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $curve = new Curve($a, $b);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($curve),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/DEREncodedKeyValueTest.php b/tests/XML/dsig11/DEREncodedKeyValueTest.php
new file mode 100644
index 00000000..2a5d260f
--- /dev/null
+++ b/tests/XML/dsig11/DEREncodedKeyValueTest.php
@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SchemaValidationTestTrait;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Test\XML\XMLDumper;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\DEREncodedKeyValue;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\DEREncodedKeyValueTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(DEREncodedKeyValue::class)]
+final class DEREncodedKeyValueTest extends TestCase
+{
+    use SchemaValidationTestTrait;
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = DEREncodedKeyValue::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_DEREncodedKeyValue.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $derEncodedKeyValue = new DEREncodedKeyValue(
+            'MGYwHwYIKoUDBwEBAQEwEwYHKoUDAgIkAAYIKoUDBwEBAgIDQwAEQLrf0MNTFKvS'
+            . 'j6pHRwtsQBdyu07oB36PZ+duQ9rOZhWXQ+acH/dP4uLxdJhZq/Z30cDGD+KND4NZ'
+            . 'jp+UZWlzWK0=',
+            'phpunit',
+        );
+
+        $this->assertEquals(
+            XMLDumper::dumpDOMDocumentXMLWithBase64Content(self::$xmlRepresentation),
+            strval($derEncodedKeyValue),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/ECKeyValueTest.php b/tests/XML/dsig11/ECKeyValueTest.php
new file mode 100644
index 00000000..516af023
--- /dev/null
+++ b/tests/XML/dsig11/ECKeyValueTest.php
@@ -0,0 +1,107 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SchemaValidationTestTrait;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Constants as C;
+use SimpleSAML\XMLSecurity\XML\dsig11\A;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractECKeyValueType;
+use SimpleSAML\XMLSecurity\XML\dsig11\B;
+use SimpleSAML\XMLSecurity\XML\dsig11\Base;
+use SimpleSAML\XMLSecurity\XML\dsig11\CoFactor;
+use SimpleSAML\XMLSecurity\XML\dsig11\Curve;
+use SimpleSAML\XMLSecurity\XML\dsig11\ECKeyValue;
+use SimpleSAML\XMLSecurity\XML\dsig11\ECParameters;
+use SimpleSAML\XMLSecurity\XML\dsig11\FieldID;
+use SimpleSAML\XMLSecurity\XML\dsig11\K1;
+use SimpleSAML\XMLSecurity\XML\dsig11\K2;
+use SimpleSAML\XMLSecurity\XML\dsig11\K3;
+use SimpleSAML\XMLSecurity\XML\dsig11\M;
+use SimpleSAML\XMLSecurity\XML\dsig11\Order;
+use SimpleSAML\XMLSecurity\XML\dsig11\PnB;
+use SimpleSAML\XMLSecurity\XML\dsig11\PublicKey;
+use SimpleSAML\XMLSecurity\XML\dsig11\Seed;
+use SimpleSAML\XMLSecurity\XML\dsig11\ValidationData;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\ECKeyValueTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractECKeyValueType::class)]
+#[CoversClass(ECKeyValue::class)]
+final class ECKeyValueTest extends TestCase
+{
+    use SchemaValidationTestTrait;
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = ECKeyValue::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_ECKeyValue.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        // Build FieldID
+        $m = new M(1024);
+        $k1 = new K1(128);
+        $k2 = new K2(256);
+        $k3 = new K3(512);
+        $pnb = new PnB($m, $k1, $k2, $k3);
+
+        $fieldId = new FieldID($pnb);
+
+        // Build Curve
+        $a = new A('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $b = new B('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $curve = new Curve($a, $b);
+
+        // Build Base
+        $base = new Base('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        // Build Order
+        $order = new Order('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        // Build CoFactor
+        $coFactor = new CoFactor(128);
+
+        // Build ValidationData
+        $seed = new Seed('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $validationData = new ValidationData($seed, C::DIGEST_SHA1);
+
+        // Build ECParameters
+        $ecParameters = new ECParameters($fieldId, $curve, $base, $order, $coFactor, $validationData);
+
+        // Build PublicKey
+        $publicKey = new PublicKey('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        // Build ECKeyValue
+        $ecKeyValue = new ECKeyValue($publicKey, 'phpunit', $ecParameters);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($ecKeyValue),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/ECParametersTest.php b/tests/XML/dsig11/ECParametersTest.php
new file mode 100644
index 00000000..7cc5e540
--- /dev/null
+++ b/tests/XML/dsig11/ECParametersTest.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Constants as C;
+use SimpleSAML\XMLSecurity\XML\dsig11\A;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractECParametersType;
+use SimpleSAML\XMLSecurity\XML\dsig11\B;
+use SimpleSAML\XMLSecurity\XML\dsig11\Base;
+use SimpleSAML\XMLSecurity\XML\dsig11\CoFactor;
+use SimpleSAML\XMLSecurity\XML\dsig11\Curve;
+use SimpleSAML\XMLSecurity\XML\dsig11\ECParameters;
+use SimpleSAML\XMLSecurity\XML\dsig11\FieldID;
+use SimpleSAML\XMLSecurity\XML\dsig11\K;
+use SimpleSAML\XMLSecurity\XML\dsig11\M;
+use SimpleSAML\XMLSecurity\XML\dsig11\Order;
+use SimpleSAML\XMLSecurity\XML\dsig11\Seed;
+use SimpleSAML\XMLSecurity\XML\dsig11\TnB;
+use SimpleSAML\XMLSecurity\XML\dsig11\ValidationData;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\ECParametersTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractECParametersType::class)]
+#[CoversClass(ECParameters::class)]
+final class ECParametersTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = ECParameters::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_ECParameters.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        // Build FieldID
+        $m = new M(1024);
+        $k = new K(64);
+        $tnb = new TnB($m, $k);
+
+        $fieldId = new FieldID($tnb);
+
+        // Build Curve
+        $a = new A('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $b = new B('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $curve = new Curve($a, $b);
+
+        // Build Base
+        $base = new Base('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        // Build Order
+        $order = new Order('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        // Build CoFactor
+        $coFactor = new CoFactor(128);
+
+        // Build ValidationData
+        $seed = new Seed('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $validationData = new ValidationData($seed, C::DIGEST_SHA1);
+
+        // Build ECParameters
+        $ecParameters = new ECParameters($fieldId, $curve, $base, $order, $coFactor, $validationData);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($ecParameters),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/FieldIDTest.php b/tests/XML/dsig11/FieldIDTest.php
new file mode 100644
index 00000000..35cf08f3
--- /dev/null
+++ b/tests/XML/dsig11/FieldIDTest.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractFieldIDType;
+use SimpleSAML\XMLSecurity\XML\dsig11\FieldID;
+use SimpleSAML\XMLSecurity\XML\dsig11\P;
+use SimpleSAML\XMLSecurity\XML\dsig11\Prime;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\FieldIDTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractFieldIDType::class)]
+#[CoversClass(FieldID::class)]
+final class FieldIDTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = FieldID::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_FieldID.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $p = new P('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $prime = new Prime($p);
+
+        $fieldId = new FieldID($prime);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($fieldId),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/GnBTest.php b/tests/XML/dsig11/GnBTest.php
new file mode 100644
index 00000000..347beaf3
--- /dev/null
+++ b/tests/XML/dsig11/GnBTest.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SchemaValidationTestTrait;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractCharTwoFieldParamsType;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\GnB;
+use SimpleSAML\XMLSecurity\XML\dsig11\M;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\GnBTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractCharTwoFieldParamsType::class)]
+#[CoversClass(M::class)]
+#[CoversClass(GnB::class)]
+final class GnBTest extends TestCase
+{
+    use SchemaValidationTestTrait;
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = GnB::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_GnB.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $m = new M(1024);
+        $gnb = new GnB($m);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($gnb),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/K1Test.php b/tests/XML/dsig11/K1Test.php
new file mode 100644
index 00000000..374f778f
--- /dev/null
+++ b/tests/XML/dsig11/K1Test.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\K1;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\K1Test
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(K1::class)]
+final class K1Test extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = K1::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_K1.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $k1 = new K1(128);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($k1),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/K2Test.php b/tests/XML/dsig11/K2Test.php
new file mode 100644
index 00000000..9a164636
--- /dev/null
+++ b/tests/XML/dsig11/K2Test.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\K2;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\K2Test
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(K2::class)]
+final class K2Test extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = K2::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_K2.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $k2 = new K2(256);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($k2),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/K3Test.php b/tests/XML/dsig11/K3Test.php
new file mode 100644
index 00000000..90f05962
--- /dev/null
+++ b/tests/XML/dsig11/K3Test.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\K3;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\K3Test
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(K3::class)]
+final class K3Test extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = K3::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_K3.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $k3 = new K3(512);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($k3),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/KTest.php b/tests/XML/dsig11/KTest.php
new file mode 100644
index 00000000..a92700ed
--- /dev/null
+++ b/tests/XML/dsig11/KTest.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\K;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\KTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(K::class)]
+final class KTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = K::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_K.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $k = new K(64);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($k),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/MTest.php b/tests/XML/dsig11/MTest.php
new file mode 100644
index 00000000..255537d2
--- /dev/null
+++ b/tests/XML/dsig11/MTest.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\M;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\MTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(M::class)]
+final class MTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = M::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_M.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $m = new M(1024);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($m),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/NamedCurveTest.php b/tests/XML/dsig11/NamedCurveTest.php
new file mode 100644
index 00000000..eb63b12a
--- /dev/null
+++ b/tests/XML/dsig11/NamedCurveTest.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractNamedCurveType;
+use SimpleSAML\XMLSecurity\XML\dsig11\NamedCurve;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\NamedCurveTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractNamedCurveType::class)]
+#[CoversClass(NamedCurve::class)]
+final class NamedCurveTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = NamedCurve::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_NamedCurve.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $namedCurve = new NamedCurve('urn:x-simplesamlphp:URI');
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($namedCurve),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/OrderTest.php b/tests/XML/dsig11/OrderTest.php
new file mode 100644
index 00000000..89a21600
--- /dev/null
+++ b/tests/XML/dsig11/OrderTest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Test\XML\XMLDumper;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\Order;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\OrderTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(Order::class)]
+final class OrderTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = Order::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_Order.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $order = new Order('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        $this->assertEquals(
+            XMLDumper::dumpDOMDocumentXMLWithBase64Content(self::$xmlRepresentation),
+            strval($order),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/PTest.php b/tests/XML/dsig11/PTest.php
new file mode 100644
index 00000000..e8d6ff34
--- /dev/null
+++ b/tests/XML/dsig11/PTest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Test\XML\XMLDumper;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\P;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\PTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(P::class)]
+final class PTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = P::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_P.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $p = new P('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        $this->assertEquals(
+            XMLDumper::dumpDOMDocumentXMLWithBase64Content(self::$xmlRepresentation),
+            strval($p),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/PnBTest.php b/tests/XML/dsig11/PnBTest.php
new file mode 100644
index 00000000..9bd20c22
--- /dev/null
+++ b/tests/XML/dsig11/PnBTest.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SchemaValidationTestTrait;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractCharTwoFieldParamsType;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractPnBFieldParamsType;
+use SimpleSAML\XMLSecurity\XML\dsig11\K1;
+use SimpleSAML\XMLSecurity\XML\dsig11\K2;
+use SimpleSAML\XMLSecurity\XML\dsig11\K3;
+use SimpleSAML\XMLSecurity\XML\dsig11\M;
+use SimpleSAML\XMLSecurity\XML\dsig11\PnB;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\PnBTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractCharTwoFieldParamsType::class)]
+#[CoversClass(AbstractPnBFieldParamsType::class)]
+#[CoversClass(K1::class)]
+#[CoversClass(K2::class)]
+#[CoversClass(K3::class)]
+#[CoversClass(M::class)]
+#[CoversClass(PnB::class)]
+final class PnBTest extends TestCase
+{
+    use SchemaValidationTestTrait;
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = PnB::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_PnB.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $m = new M(1024);
+        $k1 = new K1(128);
+        $k2 = new K2(256);
+        $k3 = new K3(512);
+        $pnb = new PnB($m, $k1, $k2, $k3);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($pnb),
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshallingElementOrder(): void
+    {
+        $m = new M(1024);
+        $k1 = new K1(128);
+        $k2 = new K2(256);
+        $k3 = new K3(512);
+        $pnb = new PnB($m, $k1, $k2, $k3);
+
+        $pnbElement = $pnb->toXML();
+        /** @var \DOMElement[] $children */
+        $children = $pnbElement->childNodes;
+
+        $this->assertEquals('dsig11:M', $children[0]->tagName);
+        $this->assertEquals('dsig11:K1', $children[1]->tagName);
+        $this->assertEquals('dsig11:K2', $children[2]->tagName);
+        $this->assertEquals('dsig11:K3', $children[3]->tagName);
+    }
+}
diff --git a/tests/XML/dsig11/PrimeTest.php b/tests/XML/dsig11/PrimeTest.php
new file mode 100644
index 00000000..8658daa0
--- /dev/null
+++ b/tests/XML/dsig11/PrimeTest.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SchemaValidationTestTrait;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractPrimeFieldParamsType;
+use SimpleSAML\XMLSecurity\XML\dsig11\P;
+use SimpleSAML\XMLSecurity\XML\dsig11\Prime;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\PrimeTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractPrimeFieldParamsType::class)]
+#[CoversClass(P::class)]
+#[CoversClass(Prime::class)]
+final class PrimeTest extends TestCase
+{
+    use SchemaValidationTestTrait;
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = Prime::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_Prime.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $p = new P('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $prime = new Prime($p);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($prime),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/PublicKeyTest.php b/tests/XML/dsig11/PublicKeyTest.php
new file mode 100644
index 00000000..ca5dd32d
--- /dev/null
+++ b/tests/XML/dsig11/PublicKeyTest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Test\XML\XMLDumper;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\PublicKey;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\PublicKeyTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(PublicKey::class)]
+final class PublicKeyTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = PublicKey::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_PublicKey.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $publicKey = new PublicKey('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        $this->assertEquals(
+            XMLDumper::dumpDOMDocumentXMLWithBase64Content(self::$xmlRepresentation),
+            strval($publicKey),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/SeedTest.php b/tests/XML/dsig11/SeedTest.php
new file mode 100644
index 00000000..28c13f01
--- /dev/null
+++ b/tests/XML/dsig11/SeedTest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Test\XML\XMLDumper;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\Seed;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\SeedTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(Seed::class)]
+final class SeedTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = Seed::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_Seed.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $seed = new Seed('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+
+        $this->assertEquals(
+            XMLDumper::dumpDOMDocumentXMLWithBase64Content(self::$xmlRepresentation),
+            strval($seed),
+        );
+    }
+}
diff --git a/tests/XML/dsig11/TnBTest.php b/tests/XML/dsig11/TnBTest.php
new file mode 100644
index 00000000..d47179ff
--- /dev/null
+++ b/tests/XML/dsig11/TnBTest.php
@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SchemaValidationTestTrait;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractCharTwoFieldParamsType;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractTnBFieldParamsType;
+use SimpleSAML\XMLSecurity\XML\dsig11\K;
+use SimpleSAML\XMLSecurity\XML\dsig11\M;
+use SimpleSAML\XMLSecurity\XML\dsig11\TnB;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\TnBTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractCharTwoFieldParamsType::class)]
+#[CoversClass(AbstractTnBFieldParamsType::class)]
+#[CoversClass(K::class)]
+#[CoversClass(M::class)]
+#[CoversClass(TnB::class)]
+final class TnBTest extends TestCase
+{
+    use SchemaValidationTestTrait;
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = TnB::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_TnB.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $m = new M(1024);
+        $k = new K(64);
+        $tnb = new TnB($m, $k);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($tnb),
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshallingElementOrder(): void
+    {
+        $m = new M(1024);
+        $k = new K(64);
+        $tnb = new TnB($m, $k);
+
+        $tnbElement = $tnb->toXML();
+        /** @var \DOMElement[] $children */
+        $children = $tnbElement->childNodes;
+
+        $this->assertEquals('dsig11:M', $children[0]->tagName);
+        $this->assertEquals('dsig11:K', $children[1]->tagName);
+    }
+}
diff --git a/tests/XML/dsig11/ValidationDataTest.php b/tests/XML/dsig11/ValidationDataTest.php
new file mode 100644
index 00000000..6932fc23
--- /dev/null
+++ b/tests/XML/dsig11/ValidationDataTest.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace SimpleSAML\XMLSecurity\Test\XML\dsig11;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use SimpleSAML\XML\DOMDocumentFactory;
+use SimpleSAML\XML\TestUtils\SerializableElementTestTrait;
+use SimpleSAML\XMLSecurity\Constants as C;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractDsig11Element;
+use SimpleSAML\XMLSecurity\XML\dsig11\AbstractECValidationDataType;
+use SimpleSAML\XMLSecurity\XML\dsig11\Seed;
+use SimpleSAML\XMLSecurity\XML\dsig11\ValidationData;
+
+use function dirname;
+use function strval;
+
+/**
+ * Class \SimpleSAML\XMLSecurity\Test\XML\dsig11\ValidationDataTest
+ *
+ * @package simplesamlphp/xml-security
+ */
+#[CoversClass(AbstractDsig11Element::class)]
+#[CoversClass(AbstractECValidationDataType::class)]
+#[CoversClass(ValidationData::class)]
+final class ValidationDataTest extends TestCase
+{
+    use SerializableElementTestTrait;
+
+
+    /**
+     */
+    public static function setUpBeforeClass(): void
+    {
+        self::$testedClass = ValidationData::class;
+
+        self::$xmlRepresentation = DOMDocumentFactory::fromFile(
+            dirname(__FILE__, 3) . '/resources/xml/dsig11_ValidationData.xml',
+        );
+    }
+
+
+    /**
+     */
+    public function testMarshalling(): void
+    {
+        $seed = new Seed('6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=');
+        $validationData = new ValidationData($seed, C::DIGEST_SHA1);
+
+        $this->assertEquals(
+            self::$xmlRepresentation->saveXML(self::$xmlRepresentation->documentElement),
+            strval($validationData),
+        );
+    }
+}
diff --git a/tests/resources/xml/dsig11_A.xml b/tests/resources/xml/dsig11_A.xml
new file mode 100644
index 00000000..c288036c
--- /dev/null
+++ b/tests/resources/xml/dsig11_A.xml
@@ -0,0 +1 @@
+<dsig11:A xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:A>
diff --git a/tests/resources/xml/dsig11_B.xml b/tests/resources/xml/dsig11_B.xml
new file mode 100644
index 00000000..33b7cc61
--- /dev/null
+++ b/tests/resources/xml/dsig11_B.xml
@@ -0,0 +1 @@
+<dsig11:B xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:B>
diff --git a/tests/resources/xml/dsig11_Base.xml b/tests/resources/xml/dsig11_Base.xml
new file mode 100644
index 00000000..a4f1bf3d
--- /dev/null
+++ b/tests/resources/xml/dsig11_Base.xml
@@ -0,0 +1 @@
+<dsig11:Base xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:Base>
diff --git a/tests/resources/xml/dsig11_CoFactor.xml b/tests/resources/xml/dsig11_CoFactor.xml
new file mode 100644
index 00000000..27655534
--- /dev/null
+++ b/tests/resources/xml/dsig11_CoFactor.xml
@@ -0,0 +1 @@
+<dsig11:CoFactor xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">128</dsig11:CoFactor>
diff --git a/tests/resources/xml/dsig11_Curve.xml b/tests/resources/xml/dsig11_Curve.xml
new file mode 100644
index 00000000..9bd1142e
--- /dev/null
+++ b/tests/resources/xml/dsig11_Curve.xml
@@ -0,0 +1,4 @@
+<dsig11:Curve xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">
+  <dsig11:A>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:A>
+  <dsig11:B>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:B>
+</dsig11:Curve>
diff --git a/tests/resources/xml/dsig11_DEREncodedKeyValue.xml b/tests/resources/xml/dsig11_DEREncodedKeyValue.xml
new file mode 100644
index 00000000..b3da335d
--- /dev/null
+++ b/tests/resources/xml/dsig11_DEREncodedKeyValue.xml
@@ -0,0 +1 @@
+<dsig11:DEREncodedKeyValue xmlns:dsig11="http://www.w3.org/2009/xmldsig11#" Id="phpunit">MGYwHwYIKoUDBwEBAQEwEwYHKoUDAgIkAAYIKoUDBwEBAgIDQwAEQLrf0MNTFKvSj6pHRwtsQBdyu07oB36PZ+duQ9rOZhWXQ+acH/dP4uLxdJhZq/Z30cDGD+KND4NZjp+UZWlzWK0=</dsig11:DEREncodedKeyValue>
diff --git a/tests/resources/xml/dsig11_ECKeyValue.xml b/tests/resources/xml/dsig11_ECKeyValue.xml
new file mode 100644
index 00000000..b99609cb
--- /dev/null
+++ b/tests/resources/xml/dsig11_ECKeyValue.xml
@@ -0,0 +1,23 @@
+<dsig11:ECKeyValue xmlns:dsig11="http://www.w3.org/2009/xmldsig11#" Id="phpunit">
+  <dsig11:ECParameters xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">
+    <dsig11:FieldID>
+      <dsig11:PnB>
+        <dsig11:M>1024</dsig11:M>
+        <dsig11:K1>128</dsig11:K1>
+        <dsig11:K2>256</dsig11:K2>
+        <dsig11:K3>512</dsig11:K3>
+      </dsig11:PnB>
+    </dsig11:FieldID>
+    <dsig11:Curve>
+      <dsig11:A>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:A>
+      <dsig11:B>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:B>
+    </dsig11:Curve>
+    <dsig11:Base>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:Base>
+    <dsig11:Order>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:Order>
+    <dsig11:CoFactor>128</dsig11:CoFactor>
+    <dsig11:ValidationData hashAlgorithm="http://www.w3.org/2000/09/xmldsig#sha1">
+      <dsig11:seed>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:seed>
+    </dsig11:ValidationData>
+  </dsig11:ECParameters>
+  <dsig11:PublicKey xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:PublicKey>
+</dsig11:ECKeyValue>
diff --git a/tests/resources/xml/dsig11_ECParameters.xml b/tests/resources/xml/dsig11_ECParameters.xml
new file mode 100644
index 00000000..97c00181
--- /dev/null
+++ b/tests/resources/xml/dsig11_ECParameters.xml
@@ -0,0 +1,18 @@
+<dsig11:ECParameters xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">
+  <dsig11:FieldID>
+    <dsig11:TnB>
+      <dsig11:M>1024</dsig11:M>
+      <dsig11:K>64</dsig11:K>
+    </dsig11:TnB>
+  </dsig11:FieldID>
+  <dsig11:Curve>
+    <dsig11:A>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:A>
+    <dsig11:B>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:B>
+  </dsig11:Curve>
+  <dsig11:Base>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:Base>
+  <dsig11:Order>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:Order>
+  <dsig11:CoFactor>128</dsig11:CoFactor>
+  <dsig11:ValidationData hashAlgorithm="http://www.w3.org/2000/09/xmldsig#sha1">
+    <dsig11:seed>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:seed>
+  </dsig11:ValidationData>
+</dsig11:ECParameters>
diff --git a/tests/resources/xml/dsig11_FieldID.xml b/tests/resources/xml/dsig11_FieldID.xml
new file mode 100644
index 00000000..ac8f688d
--- /dev/null
+++ b/tests/resources/xml/dsig11_FieldID.xml
@@ -0,0 +1,5 @@
+<dsig11:FieldID xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">
+  <dsig11:Prime>
+    <dsig11:P>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:P>
+  </dsig11:Prime>
+</dsig11:FieldID>
diff --git a/tests/resources/xml/dsig11_GnB.xml b/tests/resources/xml/dsig11_GnB.xml
new file mode 100644
index 00000000..251e9b9a
--- /dev/null
+++ b/tests/resources/xml/dsig11_GnB.xml
@@ -0,0 +1,3 @@
+<dsig11:GnB xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">
+  <dsig11:M>1024</dsig11:M>
+</dsig11:GnB>
diff --git a/tests/resources/xml/dsig11_K.xml b/tests/resources/xml/dsig11_K.xml
new file mode 100644
index 00000000..46398e80
--- /dev/null
+++ b/tests/resources/xml/dsig11_K.xml
@@ -0,0 +1 @@
+<dsig11:K xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">64</dsig11:K>
diff --git a/tests/resources/xml/dsig11_K1.xml b/tests/resources/xml/dsig11_K1.xml
new file mode 100644
index 00000000..20234633
--- /dev/null
+++ b/tests/resources/xml/dsig11_K1.xml
@@ -0,0 +1 @@
+<dsig11:K1 xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">128</dsig11:K1>
diff --git a/tests/resources/xml/dsig11_K2.xml b/tests/resources/xml/dsig11_K2.xml
new file mode 100644
index 00000000..4b91babf
--- /dev/null
+++ b/tests/resources/xml/dsig11_K2.xml
@@ -0,0 +1 @@
+<dsig11:K2 xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">256</dsig11:K2>
diff --git a/tests/resources/xml/dsig11_K3.xml b/tests/resources/xml/dsig11_K3.xml
new file mode 100644
index 00000000..f3864abd
--- /dev/null
+++ b/tests/resources/xml/dsig11_K3.xml
@@ -0,0 +1 @@
+<dsig11:K3 xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">512</dsig11:K3>
diff --git a/tests/resources/xml/dsig11_M.xml b/tests/resources/xml/dsig11_M.xml
new file mode 100644
index 00000000..3210f1e2
--- /dev/null
+++ b/tests/resources/xml/dsig11_M.xml
@@ -0,0 +1 @@
+<dsig11:M xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">1024</dsig11:M>
diff --git a/tests/resources/xml/dsig11_NamedCurve.xml b/tests/resources/xml/dsig11_NamedCurve.xml
new file mode 100644
index 00000000..94fb1416
--- /dev/null
+++ b/tests/resources/xml/dsig11_NamedCurve.xml
@@ -0,0 +1 @@
+<dsig11:NamedCurve xmlns:dsig11="http://www.w3.org/2009/xmldsig11#" URI="urn:x-simplesamlphp:URI" />
diff --git a/tests/resources/xml/dsig11_Order.xml b/tests/resources/xml/dsig11_Order.xml
new file mode 100644
index 00000000..503de2c8
--- /dev/null
+++ b/tests/resources/xml/dsig11_Order.xml
@@ -0,0 +1 @@
+<dsig11:Order xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:Order>
diff --git a/tests/resources/xml/dsig11_P.xml b/tests/resources/xml/dsig11_P.xml
new file mode 100644
index 00000000..46e2f189
--- /dev/null
+++ b/tests/resources/xml/dsig11_P.xml
@@ -0,0 +1 @@
+<dsig11:P xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:P>
diff --git a/tests/resources/xml/dsig11_PnB.xml b/tests/resources/xml/dsig11_PnB.xml
new file mode 100644
index 00000000..84e2c88d
--- /dev/null
+++ b/tests/resources/xml/dsig11_PnB.xml
@@ -0,0 +1,6 @@
+<dsig11:PnB xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">
+  <dsig11:M>1024</dsig11:M>
+  <dsig11:K1>128</dsig11:K1>
+  <dsig11:K2>256</dsig11:K2>
+  <dsig11:K3>512</dsig11:K3>
+</dsig11:PnB>
diff --git a/tests/resources/xml/dsig11_Prime.xml b/tests/resources/xml/dsig11_Prime.xml
new file mode 100644
index 00000000..f9f8ef69
--- /dev/null
+++ b/tests/resources/xml/dsig11_Prime.xml
@@ -0,0 +1,3 @@
+<dsig11:Prime xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">
+  <dsig11:P>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:P>
+</dsig11:Prime>
diff --git a/tests/resources/xml/dsig11_PublicKey.xml b/tests/resources/xml/dsig11_PublicKey.xml
new file mode 100644
index 00000000..feebd65b
--- /dev/null
+++ b/tests/resources/xml/dsig11_PublicKey.xml
@@ -0,0 +1 @@
+<dsig11:PublicKey xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:PublicKey>
diff --git a/tests/resources/xml/dsig11_Seed.xml b/tests/resources/xml/dsig11_Seed.xml
new file mode 100644
index 00000000..2c4a864d
--- /dev/null
+++ b/tests/resources/xml/dsig11_Seed.xml
@@ -0,0 +1 @@
+<dsig11:seed xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:seed>
diff --git a/tests/resources/xml/dsig11_TnB.xml b/tests/resources/xml/dsig11_TnB.xml
new file mode 100644
index 00000000..abcef386
--- /dev/null
+++ b/tests/resources/xml/dsig11_TnB.xml
@@ -0,0 +1,4 @@
+<dsig11:TnB xmlns:dsig11="http://www.w3.org/2009/xmldsig11#">
+  <dsig11:M>1024</dsig11:M>
+  <dsig11:K>64</dsig11:K>
+</dsig11:TnB>
diff --git a/tests/resources/xml/dsig11_ValidationData.xml b/tests/resources/xml/dsig11_ValidationData.xml
new file mode 100644
index 00000000..c1723176
--- /dev/null
+++ b/tests/resources/xml/dsig11_ValidationData.xml
@@ -0,0 +1,3 @@
+<dsig11:ValidationData xmlns:dsig11="http://www.w3.org/2009/xmldsig11#" hashAlgorithm="http://www.w3.org/2000/09/xmldsig#sha1">
+  <dsig11:seed>6tN39Q9d6IevlAWLeM7lQGazUnVlJOe1wCk3sro2rfE=</dsig11:seed>
+</dsig11:ValidationData>