| Dokumentation |

MOA: Serversignatur (SS) und Signaturprüfung (SP)

Anwendung

# Inhalt

1. Übersicht

2. Verwendung des Webservices

   1. XML-Requests
      1. Erstellung einer CMS bzw. CAdES-Signatur
      1. Beispiel (Base64-codiertes Datenobjekt)
      2. Beispiel (Datenobjekt als Referenz)
      2. Erstellung einer XML bzw. XAdES-Signatur
         1. Einfaches Beispiel
         2. Angabe der zu signierenden Daten
         3. Transformationen
         4. Ergänzungsobjekte
      3. Prüfung einer CMS bzw. CAdES-Signatur
         1. Einfaches Beispiel
         2. Erweitertes Beispiel
      4. Prüfung einer XML bzw. XAdES-Signatur
         1. Einfaches Beispiel
         2. Erweitertes Beispiel
         3. Prüfung eines XMLDSIG-Manifests
         4. Ergänzungsobjekte
         5. Signatur-Manifest des Security-Layers
         6. Prüfung gegen Trustprofil mit TSL Unterstützung
      5. Prüfung von PAdES Signaturen
   2. Webservice-Clients
      1. Übersicht
      2. Gemeinsamkeiten
      3. Besonderheiten von `HTTPSServerAuth.java`
      4. Besonderheiten von `HTTPSClientAuth.java`
   3. Zertifikat einer Schlüsselgruppe auslesen
3. Verwendung der Klassenbibliothek
   1. Vorbereitung
   2. Allgemeines
   3. Beispiele
   4. API-Dokumentation

1. Referenzierte Software
2. Referenzierte Spezifikation

# 1 Übersicht

Die Module Signaturprüfung (SP) und Serversignatur (SS) sind als plattformunabhängige Module ausgelegt, die entweder als Webservice über HTTP bzw. HTTPS oder als Klassenbibliothek über ein API angesprochen werden können. Dieses Handbuch beschreibt die Anwendung der beiden Module auf jede dieser beiden Arten.

# 2 Verwendung des Webservices

Dieser Abschnitt beschreibt die Verwendung der Module SP und SS über die Webservice-Schnittstelle. Im ersten Unterabschnitt werden typische XML-Requests zur Signaturerstellung mittels SS bzw. zur Signaturprüfung mittels SP vorgestellt, wie sie an das Webservice gesendet werden können. Der zweite Unterabschnitt stellt beispielhafte Implementierungen eines Webservice-Clients in Java vor, mit dem die Requests aus dem ersten Unterabschnitt an das Webservice gesendet werden können.

## 2.1 XML-Requests

Dieser Abschnitt stellt typische XML-Requests für die Erstellung einer XML/XAdES- und CMS/CAdES-Signatur mittels SS bzw. zur Prüfung einer CMS/CAdES- bzw. XML/XAdES-Signatur mittels SP vor. Zu jedem Request wird jeweils auch eine typische Response des Services besprochen.

Bitte beachten Sie: Einige der vorgestellten Requests referenzieren beispielhafte Daten auf `localhost`, z.B. `http://localhost:8080/referencedData/Text.txt`. Wenn Sie diese Beispiele ausprobieren möchten, müssen Sie dafür sorgen, dass MOA SS bzw. SP diese Daten auch tatsächlich auflösen kann. Wenn Sie Ihre Tomcat-Installation auf `localhost:8080` betreiben, ist es ausreichend, wenn sie die diesem Handbuch beiliegende Webapplikation `referencedData.war` in das Verzeichnis `webapps` Ihrer Tomcat-Installation kopieren. Ansonsten müssen Sie zusätzlich die URLs in den Requests anpassen.

### 2.1.1 Erstellung einer CMS bzw. CAdES-Signatur

MOA-SS ermöglicht die Erstellung einer herkömmlichen CMS-Signatur und einer CAdES-Signatur gemäß der Security-Layer Spezifikation. Die Auswahl ob eine herkömmliche XML oder eine Security-Layer konforme CAdES-Signatur erstellt wird, erfolgt durch das Attribute `SecurityLayerConformity` im Signaturerstelltungs-Request (siehe auch folgende Beispiele).

#### 2.1.1.1 Beispiel (Base64-codiertes Datenobjekt)

##### Request

`CreateCMSSignatureRequest.Base64Content.xml` ist ein einfacher XML-Request zur Erzeugung einer CAdES-Signatur. Sein Aufbau wird nachfolgend analysiert:

      <KeyIdentifier>KG_allgemein</KeyIdentifier>

`KG_allgemein` bezeichnet eine Schlüsselgruppe, aus der SS einen Signaturschlüssel selektieren soll und muss einer in der SP/SS-Konfigurationsdatei definierten Schlüsselgruppe entsprechen.

      <SingleSignatureInfo SecurityLayerConformity="true" PAdESConformity="true">

Für jedes `SingleSignatureInfo`Element wird eine eigene CMS/CAdES-Signatur erzeugt. Wird das Attribut `SecurityLayerConformity` auf `true` gesetzt, dann wird eine CAdES-Signatur gemäß Security-Layer Spezifikation erzeugt; d.h. es werden signierte Properties (Zeitpunkt der Signaturerstellung, das für die Signaturüberprüfung zu verwendende Zertifikat, Metainformationen zu den signierten Datenobjekten). Wird das Attribut `PAdESConformity` auf `true` gesetzt, dann wird eine CAdES-Signature entsprechend dem PAdES Standard erzeugt (die CAdES Signatur enthält in diesem Fall keinen Signaturzeitpunkt und keinen MimeType da diese Informationen im PDF eingebettet sind oder durch das PDF vorgegeben werden).

      <DataObjectInfo Structure="enveloping">
    	  <DataObject>
    	    <MetaInfo>
            <MimeType>text/plain</MimeType>
          </MetaInfo>
          <Content>
            <Base64Content>RGllc2UgRGF0ZW4gc2luZCByZWluZXIgVGV4dC4=</Base64Content>
          </Content>
        </DataObject>
    	</DataObjectInfo>

Das zu signierende Daten-Objekt muss in einem `DataObjectInfo` Element spezifiziert werden. Das Attribut `Structure` gibt an, ob die Daten in die Signatur integriert werden sollen (`Structure="enveloping"`) oder nicht (`Structure="detached"`).

Im nachfolgenden `DataObject` Element muss entweder das Attribut `Reference` (enthält eine URL, von der SS die Daten beziehen soll) gesetzt sein, oder aber die zu signierenden Daten werden explizit im Element `Base64Content` (enthält Daten in Base64 kodierter Form) spezifiziert sein. Die Angabe der zu signierenden Daten über das Attribut `Reference` und gleichzeitig im Element `Base64Content` ist nicht erlaubt. Zusätzlich muss im Element `MimeType` (unter dem Element `MetaInfo`) der MIME-Type der zu signierenden Daten spezifiziert werden.

Im konkreten Beispiel sollen die Daten in die Signatur integriert werden (`Structure="enveloping"`). Die Daten werden in diesem Beispiel mittels `Base64Content` angegeben. Der MIME-Type wird mit `text/plain` angegeben.

##### Response

`CreateCMSSignatureRequest.Base64Content.resp.xml` ist eine typische Response des SS Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

      <CreateCMSSignatureResponse
        xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
        xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
    	  <CMSSignature>MIAGCSqGSI...p92gh6wAAAAAAAA=</CMSSignature>
      </CreateCMSSignatureResponse>

`CreateCMSSignatureResponse` enthält je erzeugter Signatur ein Element `CMSSignature` (in diesem Fall genau ein Element). `CMSSignature` enthält die von SS erzeugte CAdES-Signatur (da `SecurityLayerConformity="true"` im Request angegeben wurde) als Base64-codierten Wert. Das unterzeichnete Datenobjekt ist in der Signaturstruktur selbst enthalten (`enveloping`).

#### 2.1.1.2 Beispiel (Datenobjekt als Referenz)

##### Request

`CreateCMSSignatureRequest.Reference.xml` ist ein einfacher XML-Request zur Erzeugung einer CMS-Signatur. Sein Aufbau wird nachfolgend analysiert:

      <KeyIdentifier>KG_allgemein</KeyIdentifier>

`KG_allgemein` bezeichnet eine Schlüsselgruppe, aus der SS einen Signaturschlüssel selektieren soll und muss einer in der SP/SS-Konfigurationsdatei definierten Schlüsselgruppe entsprechen.

      <SingleSignatureInfo SecurityLayerConformity="false">

Für jedes `SingleSignatureInfo`Element wird eine eigene CMS/CAdES-Signatur erzeugt. Wird das Attribut `SecurityLayerConformity` auf `true` gesetzt, dann wird eine CAdES-Signatur gemäß Security-Layer Spezifikation erzeugt; d.h. es werden signierte Properties (Zeitpunkt der Signaturerstellung, das für die Signaturüberprüfung zu verwendende Zertifikat, Metainformationen zu den signierten Datenobjekten).

      <DataObjectInfo Structure="detached">
    	  <DataObject>
    	    <MetaInfo>
            <MimeType>text/plain</MimeType>
          </MetaInfo>
          <Content Reference="http://localhost:8080/moa-spss-handbook-referencedData/Text.txt"/>
        </DataObject>
    	</DataObjectInfo>

Das zu signierende Daten-Objekt muss in einem `DataObjectInfo` Element spezifiziert werden. Das Attribut `Structure` gibt an, ob die Daten in die Signatur integriert werden sollen (`Structure="enveloping"`) oder nicht (`Structure="detached"`).

Im nachfolgenden `DataObject` Element muss entweder das Attribut `Reference` (enthält eine URL, von der SS die Daten beziehen soll) gesetzt sein, oder aber die zu signierenden Daten werden explizit im Element `Base64Content` (enthält Daten in Base64 kodierter Form) spezifiziert sein. Die Angabe der zu signierenden Daten über das Attribut `Reference` und gleichzeitig im Element `Base64Content` ist nicht erlaubt. Zusätzlich muss im Element `MimeType` (unter dem Element `MetaInfo`) der MIME-Type der zu signierenden Daten spezifiziert werden.

Im konkreten Beispiel sollen die Daten nicht in die Signatur integriert werden (`Structure="detached"`). Die Daten werden in diesem Beispiel mittels der Attributs `Refernce` angegeben und SS muss es von dieser URL laden. Der MIME-Type wird mit `text/plain` angegeben.

##### Response

`CreateCMSSignatureRequest.Reference.resp.xml` ist eine typische Response des SS Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

      <CreateCMSSignatureResponse
        xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
        xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
    	  <CMSSignature>MIAGCSqGSI...SwxhbA9pAAAAAAAA</CMSSignature>
      </CreateCMSSignatureResponse>

`CreateCMSSignatureResponse` enthält je erzeugter Signatur ein Element `CMSSignature` (in diesem Fall genau ein Element). `CMSSignature` enthält die von SS erzeugte CMS-Signatur (da `SecurityLayerConformity="false"` im Request angegeben wurde) als Base64-codierten Wert. Das unterzeichnete Datenobjekt ist in der Signaturstruktur nicht enthalten (`detached`).

### 2.1.2 Erstellung einer XML bzw. XAdES-Signatur

MOA-SS ermöglicht die Erstellung einer herkömmlichen XML-Signatur und einer XAdES-Signatur gemäß der Security-Layer Spezifikation. Die Auswahl ob eine herkömmliche XML oder eine Security-Layer konforme XAdES-Signatur erstellt wird, erfolgt durch das Attribute `SecurityLayerConformity` im Signaturerstelltungs-Request (siehe auch folgende Beispiele).

Im Falle einer XAdES-Signatur, kann entweder eine XAdES-Signatur in der Version 1.1.1 oder in der Version 1.4.2 erstellt werden. Dies hängt von der in der MOA-SS Konfiguration angegeben XAdES-Version ab (siehe hierzu Konfiguration der XAdES Version).

#### 2.1.2.1 Einfaches Beispiel

##### Request

`CreateXMLSignatureRequest.Simple.xml` ist ein einfacher XML-Request zur Erzeugung einer XML-Signatur. Sein Aufbau wird nachfolgend analysiert:

      <KeyIdentifier>KG_allgemein</KeyIdentifier>

`KG_allgemein` bezeichnet eine Schlüsselgruppe, aus der SS einen Signaturschlüssel selektieren soll und muss einer in der SP/SS-Konfigurationsdatei definierten Schlüsselgruppe entsprechen.

      <SingleSignatureInfo SecurityLayerConformity="false">

Für jedes `SingleSignatureInfo`Element wird eine eigene XML-Signatur erzeugt. Wird das Attribut `SecurityLayerConformity` auf `true` gesetzt, dann wird eine XML-Signatur gemäß Security-Layer Spezifikation erzeugt; d.h. es werden signierte Properties (Zeitpunkt der Signaturerstellung, das für die Signaturüberprüfung zu verwendende Zertifikat, Metainformationen zu den signierten Datenobjekten) und ein Manifest, das alle implizite Transformationsparameter enthält, zur Signatur hinzugefügt (=eine XAdES Signatur).

      <DataObjectInfo Structure="enveloping">
        <DataObject>
          <XMLContent>Diese Daten werden signiert.<XMLContent>
        </DataObject>

Für jedes Daten-Objekt, das in die XML-Signatur als `dsig:Reference` aufgenommen werden soll, muss ein `DataObjectInfo` Element spezifiziert werden. Das Attribut `Structure` gibt an, ob die Daten in die Signatur in ein `dsig:Object` Element integriert werden sollen (`Structure="enveloping"`), oder über einen URL referenziert werden sollen (`Structure="detached"`).

Im Fall von `Structure="enveloping"` muss im nachfolgenden `DataObject` Element entweder das Attribut `Reference` (enthält eine URL, von der SS die Daten beziehen soll) gesetzt sein, oder aber die zu signierenden Daten werden explizit in einem der Elemente `Base64Content` (enthält Daten in Base64 kodierter Form) oder `XMLContent` (enthält Daten als beliebiges XML-Fragment) oder `LocRefContent` (enthält eine URL, von der SS die Daten beziehen soll; in diesem Fall also gleichwertig wie ein gesetztes Attribut `Reference`) spezifiziert sein. Die Angabe der zu signierenden Daten über das Attribut `Reference` und gleichzeitig einem der Elemente `Base64Content` oder `XMLContent` oder `LocRefContent` ist nicht erlaubt.

Im Fall von `Structure="detached"` muss das Attribut `Reference` im nachfolgenden `DataObject` Element gesetzt sein. Es enthält jene URL, die zur Referenzierung der Daten als Wert von `dsig:Reference/@URI` in die XML-Signatur aufgenommen wird. Die Angabe eines der Element `Base64Content` oder `XMLContent` oder `LocRefContent` ist optional. Unterbleibt die Angabe, bezieht SS die Daten von der URL im Attribut `Reference`. Wird eines der Elemente verwendet, bezieht SS die Daten durch Analyse des angegebenen Elements (siehe obiger Absatz).

Im konkreten Beispiel sollen die Daten in ein `dsig:Object` Element integriert werden (`Structure="enveloping"`). Die Daten werden mittels `XMLContent` als XML-Fragment (ein einfacher Textknoten) angegeben.

      <CreateTransformsInfoProfile>
        <CreateTransformsInfo>
          <FinalDataMetaInfo>
            <MimeType>text/plain<MimeType>
          </FinalDataMetaInfo>
        </CreateTransformsInfo>
      </CreateTransformsInfoProfile>

Zu jedem Daten-Objekt können optional Transformationen (z.B. XPath, XSLT, Base64-Decodierung, etc.) angegeben werden. Werden - wie hier im Beispiel - keine Transformationen angegeben, so muss zumindest der MIME-Type der zu signierenden Daten spezifiziert werden.

##### Response

`CreateXMLSignatureRequest.Simple.resp.xml` ist eine typische Response des SS Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

      <CreateXMLSignatureResponse
        xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
        xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
        <SignatureEnvironment>
          <dsig:Signature Id="signature-1-1" xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
            <dsig:SignedInfo>
              ...
              <dsig:Reference Id="reference-1-1" URI="#xpointer(id(&apos;signed-data-1-1-1&apos;)/node())">
              ...
              </dsig:Reference>
              ...
            </dsig:SignedInfo>
            ...
            <dsig:Object Id="signed-data-1-1-1">Diese Daten werden signiert.</dsig:Object>
          </dsig:Signature>
        </SignatureEnvironment>
      </CreateXMLSignatureResponse>

`CreateXMLSignatureResponse` enthält je erzeugter Signatur ein Element `SignatureEnvironment` (in diesem Fall genau ein Element). `SignatureEnvironment` enthält die von SS erzeugte XML-Signatur, die im obigen Request spezifiziert wurde. Man erkennt, dass die XML-Signatur genau ein Daten-Objekt unterzeichnet (ein `dsig:Reference` Element ist enthalten). Das unterzeichnete Datenobjekt ist in der Signaturstruktur selbst enthalten (`enveloping`), und zwar in einem `dsig:Object` Element.

#### 2.1.2.2 Angabe der zu signierenden Daten

##### Request

Dieses Beispiel stellt die vielfältigen Möglichkeiten vor, wie MOA SS mitgeteilt werden kann, welche Daten signiert (wenn keine Transformationen angegeben werden) bzw. als Eingangsdaten für die Berechnung der Transformationen verwendet werden sollen (wenn Transformationen angegeben werden).

Mit `CreateXMLSignatureRequest.Refs.xml` sollen insgesamt neun Datenobjekte signiert werden:

      <CreateXMLSignatureRequest
        xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
        xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
        <KeyIdentifier>KG_allgemein</KeyIdentifier>
        <SingleSignatureInfo SecurityLayerConformity="false">

Die Signatur soll mit dem Schlüssel `KG_allgemein` erstellt werden; jene Elemente, die speziell für eine Security-Layer V1.1 konforme Signatur notwendig sind (vergleiche Einfaches Beispiel), brauchen nicht erstellt zu werden (`SecurityLayerConformity="false"`).

      <DataObjectInfo Structure="enveloping" ChildOfManifest="true">
        <DataObject>
          <Base64Content>RGllc2UgRGF0ZW4gd2FyZW4gYmFzZTY0IGtvZGllcnQu</Base64Content>
        </DataObject>
        <CreateTransformsInfoProfile>
          <CreateTransformsInfo>
            <FinalDataMetaInfo>
              <MimeType>text/plain</MimeType>
            </FinalDataMetaInfo>
          </CreateTransformsInfo>
        </CreateTransformsInfoProfile>
      </DataObjectInfo>

Die Daten sollen in der Enveloping Form in die Signatur integriert werden, d. h. die Daten werden in einem `dsig:Object` als Teil der XML-Struktur der Signatur aufgenommen (`Structure="enveloping"`). Weiters sollen die Daten nicht über über eine `dsig:Reference` in `dsig:SignedInfo`, sondern über eine `dsig:Reference` in einem eigenen `dsig:Manifest` aufgenommen werden (`ChildOfManifest="true"`).

Die Daten selbst werden explizit in base64 kodierter Form als Inhalt des Elements `Base64Content` angegeben. Das Attribut `DataObject/@Reference` darf nicht angegeben werden, da die Daten in der Enveloping Form integriert werden sollen, und `Base64Content` verwendet wird.

Es werden - wie in allen übrigen Fällen dieses Beispiels - keine Transformationen angegeben. Der Mime-Type der zu signierenden Daten wird als `text/plain` angegeben, da der Inhalt von `Base64Content` die base64-Kodierung des Texts `Diese Daten waren base64 kodiert.` ist.

      <DataObjectInfo Structure="enveloping" ChildOfManifest="false">
        <DataObject>
          <XMLContent><doc:XMLDocument xmlns:doc="urn:document">
            <doc:Paragraph>Ich bin der erste Absatz in diesem Dokument.</doc:Paragraph>
            <doc:Paragraph ParaId="Para2">Und ich bin der zweite Absatz in diesem Dokument.
              Ich habe weiters ein eigenens ID-Attribut bekommen.</doc:Paragraph>
          </doc:XMLDocument></XMLContent>
        </DataObject>
        <CreateTransformsInfoProfile>
          <CreateTransformsInfo>
            <FinalDataMetaInfo>
              <MimeType>application/xml</MimeType>
            </FinalDataMetaInfo>
          </CreateTransformsInfo>
        </CreateTransformsInfoProfile>
      </DataObjectInfo>

Die Daten sollen in der Enveloping Form in die Signatur integriert werden, d. h. die Daten werden in einem `dsig:Object` als Teil der XML-Struktur der Signatur aufgenommen (`Structure="enveloping"`). Diesmal sollen die Daten direkt über eine `dsig:Reference` in `dsig:SignedInfo` aufgenommen werden (`ChildOfManifest="false"`).

Die Daten selbst werden explizit als XML-Fragment als Inhalt des Elements `XMLContent` angegeben. Das Attribut `DataObject/@Reference` darf nicht angegeben werden, da die Daten in der Enveloping Form integriert werden sollen, und `XMLContent` verwendet wird.

Der Mime-Type der zu signierenden Daten wird als `application/xml` angegeben.

      <DataObjectInfo Structure="enveloping" ChildOfManifest="false">
        <DataObject Reference="http://localhost:8080/referencedData/Text.txt"/>
        <CreateTransformsInfoProfile>
          <CreateTransformsInfo>
            <FinalDataMetaInfo>
              <MimeType>text/plain</MimeType>
            </FinalDataMetaInfo>
          </CreateTransformsInfo>
        </CreateTransformsInfoProfile>
      </DataObjectInfo>

Die Daten sollen in der Enveloping Form in die Signatur integriert werden, d. h. die Daten werden in einem `dsig:Object` als Teil der XML-Struktur der Signatur aufgenommen (`Structure="enveloping"`). Wiederum sollen die Daten direkt über eine `dsig:Reference` in `dsig:SignedInfo` aufgenommen werden (`ChildOfManifest="false"`).

Die Daten werden diesmal nicht explizit angegeben, sondern mittels der URL in `DataObject/@Reference` referenziert. MOA SS versucht diese URL aufzulösen, um zu den zu signierenden Daten zu gelangen. `Base64Content` oder `XMLContent` oder `LocRefContent` dürfen nicht verwendet werden, da die Daten in der Enveloping Form integriert werden sollen, und bereits `DataObject/@Reference` eingesetzt wird.

Der Mime-Type der zu signierenden Daten wird als `text/plain` angegeben.

      <DataObjectInfo Structure="enveloping" ChildOfManifest="false">
        <DataObject>
          <LocRefContent>http://localhost:8080/referencedData/Text.txt</LocRefContent>
        </DataObject>
        <CreateTransformsInfoProfile>
          <CreateTransformsInfo>
            <FinalDataMetaInfo>
              <MimeType>text/plain</MimeType>
            </FinalDataMetaInfo>
          </CreateTransformsInfo>
        </CreateTransformsInfoProfile>
      </DataObjectInfo>

Die Daten sollen wiederum in der Enveloping Form in die Signatur integriert werden, d. h. die Daten werden in einem `dsig:Object` als Teil der XML-Struktur der Signatur aufgenommen (`Structure="enveloping"`). Wiederum sollen die Daten direkt über eine `dsig:Reference` in `dsig:SignedInfo` aufgenommen werden (`ChildOfManifest="false"`).

Die Daten werden wie im vorhergehenden Fall nicht explizit angegeben, sondern referenziert. Diesmal wird die URL jedoch nicht `DataObject/@Reference` verwendet, sondern als Textinhalt des Elements `LocRefContent` (`LocRef` steht für Location Reference). `DataObject/@Reference` darf in diesem Fall nicht verwendet werden. Diese Methode ist semantisch völlig ident mit dem vorhergehenden Fall.

Der Mime-Type der zu signierenden Daten wird als `text/plain` angegeben.

      <DataObjectInfo Structure="detached" ChildOfManifest="true">
        <DataObject Reference="http://localhost:8080/referencedData/Text.b64">
          <Base64Content>RGllc2UgRGF0ZW4gd2FyZW4gYmFzZTY0IGtvZGllcnQu</Base64Content>
        </DataObject>
        <CreateTransformsInfoProfile>
          <CreateTransformsInfo>
            <FinalDataMetaInfo>
              <MimeType>text/plain</MimeType>
            </FinalDataMetaInfo>
          </CreateTransformsInfo>
        </CreateTransformsInfoProfile>
      </DataObjectInfo>

Die Daten sollen diesmal in der Detached Form in die Signatur aufgenommen werden, d. h. die Daten werden nicht direkt in die Signaturstruktur integriert, sondern lediglich mittels URI im Attribut `URI` der anzufertigenden `dsig:Reference` referenziert (`Structure="detached"`). Die Daten sollen indirekt über eine `dsig:Reference` eines `dsig:Manifest`s aufgenommen werden (`ChildOfManifest="true"`).

Die URI in `DataObject/@Reference` enthält dabei die URI, die zur Referenzierung in `dsig:Reference/@URI` aufgenommen werden soll. Die Daten selbst hingegen werden im diesem Beispiel explizit in base64 kodierter Form als Inhalt des Elements `Base64Content` angegeben. MOA SS löst also keine URL zur Erlangung der Daten auf, sondern verwendet den Inhalt von `Base64Content`.

Der Mime-Type der zu signierenden Daten wird als `text/plain` angegeben.

      <DataObjectInfo Structure="detached" ChildOfManifest="false">
        <DataObject Reference="NichtAufloesbareReferenz1">
          <XMLContent><doc:XMLDocument xmlns:doc="urn:document">
            <doc:Paragraph>Ich bin der erste Absatz in diesem Dokument.</doc:Paragraph>
            <doc:Paragraph ParaId="Para2">Und ich bin der zweite Absatz in diesem Dokument.
              Ich habe weiters ein eigenens ID-Attribut bekommen.</doc:Paragraph>
            </doc:XMLDocument>
          </XMLContent>
        </DataObject>
        <CreateTransformsInfoProfile>
          <CreateTransformsInfo>
            <FinalDataMetaInfo>
              <MimeType>application/xml</MimeType>
            </FinalDataMetaInfo>
          </CreateTransformsInfo>
        </CreateTransformsInfoProfile>
      </DataObjectInfo>

Die Daten sollen auch diesmal in der Detached Form in die Signatur aufgenommen werden, d. h. die Daten werden nicht direkt in die Signaturstruktur integriert, sondern lediglich mittels URI im Attribut `URI` der anzufertigenden `dsig:Reference` referenziert (`Structure="detached"`). Diesmal sollen die Daten direkt über eine `dsig:Reference` in `dsig:SignedInfo` aufgenommen werden (`ChildOfManifest="false"`).

Die URI in `DataObject/@Reference` enthält dabei die URI, die zur Referenzierung in `dsig:Reference/@URI` aufgenommen werden soll. Die Daten selbst hingegen werden im diesem Beispiel explizit als XML-Fragment in `XMLContent` angegeben. MOA SS löst auch hier keine URL zur Erlangung der Daten auf, sondern verwendet den Inhalt von `XMLContent`. Zur Verdeutlichung dieses Umstandes wurde die URI in `DataObject/@Reference` auf einen Wert gesetzt, der von MOA SS ganz sicher nicht aufgelöst werden kann (`NichtAufloesbareReferenz1`).

Der Mime-Type der zu signierenden Daten wird als `application/xml` angegeben.

      <DataObjectInfo Structure="detached" ChildOfManifest="false">
        <DataObject Reference="http://localhost:8080/referencedData/Text.txt">
        </DataObject>
        <CreateTransformsInfoProfile>
          <CreateTransformsInfo>
            <FinalDataMetaInfo>
              <MimeType>text/plain</MimeType>
            </FinalDataMetaInfo>
          </CreateTransformsInfo>
        </CreateTransformsInfoProfile>
      </DataObjectInfo>

Wiederum sollen die Daten in der Detached Form in die Signatur aufgenommen werden (`Structure="detached"`). Wie zuvor sollen die Daten direkt über eine `dsig:Reference` in `dsig:SignedInfo` aufgenommen werden (`ChildOfManifest="false"`).

Die URI in `DataObject/@Reference` enthält dabei die URI, die zur Referenzierung in `dsig:Reference/@URI` aufgenommen werden soll. Nachdem eine explizite Angabe der Daten mittels `Base64Content`, `XMLContent` oder `LocRefContent` unterbleibt, wird MOA SS versuchen, die URI in `dsig:Reference/@URI` als URL aufzulösen, um so zu den zu signierenden Daten zu gelangen.

Der Mime-Type der zu signierenden Daten wird als `text/plain` angegeben.

      <DataObjectInfo Structure="detached" ChildOfManifest="false">
        <DataObject Reference="NichtAufloesbareReferenz2">
          <LocRefContent>http://localhost:8080/referencedData/Text.txt</LocRefContent>
        </DataObject>
       <CreateTransformsInfoProfile>
         <CreateTransformsInfo>
           <FinalDataMetaInfo>
             <MimeType>text/plain</MimeType>
           </FinalDataMetaInfo>
          </CreateTransformsInfo>
        </CreateTransformsInfoProfile>
      </DataObjectInfo>

Wiederum sollen die Daten in der Detached Form in die Signatur aufgenommen werden (`Structure="detached"`). Wie zuvor sollen die Daten direkt über eine `dsig:Reference` in `dsig:SignedInfo` aufgenommen werden (`ChildOfManifest="false"`).

Die URI in `DataObject/@Reference` enthält dabei die URI, die zur Referenzierung in `dsig:Reference/@URI` aufgenommen werden soll. Den Hinweis, wie MOA SS zu den zu signierenden Daten gelangen soll, ist jedoch in LocRefContent enthalten. MOA SS wird also versuchen, die dort enthaltene URL aufzulösen, um zu den zu signierenden Daten zu gelangen. Zur Verdeutlichung dieses Umstandes wurde die URI in `DataObject/@Reference` auf einen Wert gesetzt, der von MOA SS ganz sicher nicht aufgelöst werden kann (`NichtAufloesbareReferenz2`). Diese Art der Datenangabe kann eingesetzt werden, wenn die Daten zum Zeitpunkt der Signaturerstellung von einem anderen Ort bezogen werden müssen, als später dann bei der Signaturprüfung.

Der Mime-Type der zu signierenden Daten wird als `text/plain` angegeben.

      <DataObjectInfo Structure="detached" ChildOfManifest="false">
        <DataObject Reference=""/>
        <CreateTransformsInfoProfile>
          <CreateTransformsInfo>
            <dsig:Transforms>
              <dsig:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
            </dsig:Transforms>
            <FinalDataMetaInfo>
              <MimeType>application/xml</MimeType>
            </FinalDataMetaInfo>
          </CreateTransformsInfo>
        </CreateTransformsInfoProfile>
      </DataObjectInfo>

Im letzten Fall schließlich sollen wiederum Daten in der Detached Form in die Signatur aufgenommen werden (`Structure="detached"`). Wie zuvor sollen die Daten direkt über eine `dsig:Reference` in `dsig:SignedInfo` aufgenommen werden (`ChildOfManifest="false"`).

Die Referenz auf die zu signierenden Daten ist wiederum in `DataObject/@Reference` enthalten; sie verweist diesmal jedoch nicht auf ein externes Dokument, sondern auf das gesamte (XML-)Dokument, in das die zu erstellende Signatur integriert werden soll, und zwar, indem `DataObject/@Reference` den leeren String (`""`) enthält. Nachdem dadurch zwangsläufig auch die Signatur in den zu signierenden Daten enthalten wäre, wird die Signatur durch die Angabe einer Enveloped Signature Transform aus den zu signierenden Daten herausgenommen, bevor darüber der Hashwert berechnet wird (dsig:Transform).

Offen bleibt die Frage, wie MOA SS nun weiß, in welches (XML-)Dokument es die die Signatur integrieren soll. Siehe dazu die Erläuterungen zum nächsten Ausschnitts des Requests.

Der Mime-Type der zu signierenden Daten wird als `application/xml` angegeben.

      <CreateSignatureInfo>
        <CreateSignatureEnvironment>
          <LocRefContent>http://localhost:8080/referencedData/XMLDocument.xml</LocRefContent>
        </CreateSignatureEnvironment>
        <CreateSignatureEnvironmentProfile>
          <CreateSignatureLocation Index="4" xmlns:doc="urn:document">/doc:XMLDocument</CreateSignatureLocation>
        </CreateSignatureEnvironmentProfile>
      </CreateSignatureInfo>

Das Element `CreateSignatureInfo` ist grundsätzlich optional, und muss nur angegeben werden, wenn die zu erstellende Signatur von MOA SS in ein bestehendes XML-Dokument integriert werden soll (was in diesem Beispiel ja der Fall ist).

`CreateSignatureEnvironment` enthält das XML-Dokument, in das die zu erstellende Signatur integriert werden soll. In diesem Beispiel wird dieses Dokument mit Hilfe von `LocRefContent` referenziert, d. h. MOA SS wird versuchen, die darin enthaltene URL aufzulösen, um das XML-Dokument zu erhalten. Alternativ könnte auch `Base64Content` (explizite Angabe des XML-Dokuments in base64 kodierter Form) oder `XMLContent` (direkte Angabe des XML-Dokuments im Request) verwendet werden.

`CreateSignatureLocation` enthält die Angabe jener Stelle, an der die Signatur in das XML-Dokument eingesetzt werden soll. Der Inhalt dieses Elements bezeichnet mittels XPath-Ausdruck das Parent-Element der Signatur, der Wert des Attributs `CreateSignatureLocation/@Index` enthält den Offset innerhalb dieses Parent-Elements. Betrachten Sie zur Verdeutlichung das XML-Dokument `XMLDocument.xml`, in das die Signatur integriert werden soll: Die Signatur soll unmittelbar nach dem zweiten `doc:Paragraph` Element in das XML-Dokument eingefügt werden. Der Inhalt von `CreateSignatureLocation` (`/doc:XMLDocument`) selektiert das zukünftige Parent-Element der Signatur, also `doc:XMLDocument`. Das Attribut `Index` enthält deshalb den Wert `4` (und nicht etwa `2` oder `3`), da erstens bei `0` zu zählen begonnen wird, und zweitens auch die Text-Knoten, die lediglich Whitespace enthalten, für diesen Offset zählen (um diese Textknoten erkennen zu können, müssen Sie das XML-Dokument in einem Text-Editor öffnen). Beachten Sie weiters, dass das im XPath-Ausdruck verwendete Namespace-Prefix `doc` im Kontext des Elements `CreateSignatureLocation` bekannt sein muss. Deshalb enthält dieses Element auch die entsprechende Namespace-Deklaration (`xmlns:doc="urn:document"`).

##### Response

`CreateXMLSignatureRequest.Refs.resp.xml` ist eine typische Response des SS Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

      <CreateXMLSignatureResponse
        xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
        xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
        <SignatureEnvironment>
          <doc:XMLDocument xmlns:doc="urn:document">
            <doc:Paragraph>Ich bin der erste Absatz in diesem Dokument.</doc:Paragraph>
            <doc:Paragraph ParaId="Para2">Und ich bin der zweite Absatz in diesem Dokument.
              Ich habe weiters ein eigenens ID-Attribut bekommen.</doc:Paragraph>
            <dsig:Signature Id="signature-1-1" xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
    		    <dsig:SignedInfo>
                <dsig:CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
                <dsig:SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha1"/>

Die Antwort enthält in `SignatureEnvironment` das Ergebnis der Signaturerstellung. Nachdem die Signatur in ein bestehendes XML-Dokument integriert werden sollte, enthält `SignatureEnvironment` das Dokument-Element dieses XML-Dokuments (`doc:XMLDocument`). Man erkennt auch gut, dass die XML-Signatur als fünfter Kindknoten (Offset `4`) von `doc:XMLDocument` eingefügt wurde.

                <dsig:Reference Id="reference-1-2" URI="#xpointer(id('signed-data-1-2-1')/node())">
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>A8ml6/aZKCmj1hONwvLItIwGHoc=</dsig:DigestValue>
                </dsig:Reference>

Diese `dsig:Reference` wurde auf Grund des zweiten `DataObjectInfo` Elements im Request erstellt. Man erkennt gut den Verweis in `dsig:Reference/@URI` auf das `dsig:Object`, das die signierten Daten enthält (der XPointer verweist auf sämtliche Kindknoten jenes Elements, das ein ID-Attribut mit dem Wert `signed-data-1-2-1` aufweist, des ersten vorkommenden `dsig:Object`s der Signatur).

                <dsig:Reference Id="reference-1-3" URI="#xpointer(id('signed-data-1-3-1')/node())">
                  <dsig:Transforms>
                    <dsig:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#base64"/>
                  </dsig:Transforms>
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>0P878Dsmtxv5goj+6KgNmj6S/EE=</dsig:DigestValue>
                </dsig:Reference>

Diese `dsig:Reference` wurde auf Grund des dritten `DataObjectInfo` Elements im Request erstellt. Die Text-Daten wurden von der angegebenen URL (`http://localhost:8080/referencedData/Text.txt`) aufgelöst und in das `dsig:Object` mit dem ID-Attribut `signed-data-1-3-1` gesteckt. Um Probleme mit nicht in XML darstellbare Zeichen zu vermeiden, wurde der Text nicht direkt signiert, sondern in base64 kodierter Form in das `dsig:Object` integriert, und eine Transformation zur base64 Dekodierung spezifiziert.

                <dsig:Reference Id="reference-1-4" URI="#xpointer(id('signed-data-1-4-1')/node())">
                  <dsig:Transforms>
                    <dsig:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#base64"/>
                  </dsig:Transforms>
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>0P878Dsmtxv5goj+6KgNmj6S/EE=</dsig:DigestValue>
                </dsig:Reference>

Diese `dsig:Reference` wurde auf Grund des vierten `DataObjectInfo` Elements im Request erstellt. Wie schon bei der Beschreibung des Requests angeführt, ist die erstellte`dsig:Reference` semantisch genau gleich wie die vorhergehende.

                <dsig:Reference Id="reference-1-6" URI="NichtAufloesbareReferenz1">
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>2b83+NbXDFijHzz+sH0T7fM36sA=</dsig:DigestValue>
                </dsig:Reference>

Diese `dsig:Reference` wurde auf Grund des sechsten `DataObjectInfo` Elements im Request erstellt. Die zu signierenden Daten wurden aus dem `XMLContent` des Requests entnommen, als Wert von `dsig:Reference/@URI` wurde der Wert von `DataObjectInfo/@Reference` übernommen.

                <dsig:Reference Id="reference-1-7" URI="http://localhost:8080/referencedData/Text.txt">
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>0P878Dsmtxv5goj+6KgNmj6S/EE=</dsig:DigestValue>
                </dsig:Reference>

Diese `dsig:Reference` wurde auf Grund des siebenten `DataObjectInfo` Elements im Request erstellt. Um zu den zu signierenden Daten zu gelangen, wurde von MOA SS die URL in `DataObjectInfo/@Reference` aufgelöst. Gleichermaßen wurde die URL in `dsig:Reference/@URI` übernommen.

                <dsig:Reference Id="reference-1-8" URI="NichtAufloesbareReferenz2">
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>0P878Dsmtxv5goj+6KgNmj6S/EE=</dsig:DigestValue>
                </dsig:Reference>

Diese `dsig:Reference` wurde auf Grund des achten `DataObjectInfo` Elements im Request erstellt. Um zu den zu signierenden Daten zu gelangen, wurde von MOA SS die URL in LocRefContent aufgelöst. In `dsig:Reference/@URI` wurde der Wert aus `DataObjectInfo/@Reference` übernommen.

                <dsig:Reference Id="reference-1-9" URI="">
                  <dsig:Transforms>
                    <dsig:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
                  </dsig:Transforms>
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>2b83+NbXDFijHzz+sH0T7fM36sA=</dsig:DigestValue>
                </dsig:Reference>

Diese `dsig:Reference` wurde auf Grund des neunten `DataObjectInfo` Elements im Request erstellt. Als zu signierende Daten wurde das XML-Dokument ausgewählt, in das die XML-Signatur integriert werden solle. Vor der Berechnung des Hashwerts wurde eine Enveloped Signature Transformation zwischengeschaltet, welche die XML-Struktur der Signatur selbst aus den Hash-Eingangsdaten herausschneidet.

                <dsig:Reference Type="http://www.w3.org/2000/09/xmldsig#Manifest" URI="#dsig-manifest-1-1">
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>mNsxUkFoF46XZVBivBo4aasFCTQ=</dsig:DigestValue>
                </dsig:Reference>

Diese `dsig:Reference` verweist auf das `dsig:Manifest` weiter unten in der XML-Struktur der Signatur. Das `dsig:Manifest` wurde angelegt, weil bei zwei `DataObjectInfo`s im Request das Attribut `ChildOfManifest` auf den Wert `true` gesetzt wurde.

              </dsig:SignedInfo>
              <dsig:SignatureValue>...</dsig:SignatureValue>
              <dsig:KeyInfo>...</dsig:KeyInfo>
              <dsig:Object Id="signed-data-1-2-1">
                <doc:XMLDocument xmlns:doc="urn:document">
                  <doc:Paragraph>Ich bin der erste Absatz in diesem Dokument.</doc:Paragraph>
                  <doc:Paragraph ParaId="Para2">Und ich bin der zweite Absatz in diesem Dokument.
                    Ich habe weiters ein eigenens ID-Attribut bekommen.</doc:Paragraph>
                </doc:XMLDocument>
              </dsig:Object>
              <dsig:Object Id="signed-data-1-3-1">RGllc2UgRGF0ZW4gc2luZCByZWluZXIgVGV4dC4=</dsig:Object>
              <dsig:Object Id="signed-data-1-4-1">RGllc2UgRGF0ZW4gc2luZCByZWluZXIgVGV4dC4=</dsig:Object>
              <dsig:Object Id="signed-data-1-1-1">RGllc2UgRGF0ZW4gd2FyZW4gYmFzZTY0IGtvZGllcnQu</dsig:Object>

`SignatureValue` und `KeyInfo` werden an dieser Stelle nicht näher betrachtet.

Das erste `dsig:Object` enthält die Daten aus dem zweiten `DataObjectInfo`; das zweite `dsig:Object` jene aus dem dritten `DataObjectInfo`; das dritte `dsig:Object` jene aus dem vierten `DataObjectInfo`; das vierte `dsig:Object` schließlich jene aus dem ersten `DataObjectInfo`.

              <dsig:Object>
                <dsig:Manifest Id="dsig-manifest-1-1">
                  <dsig:Reference Id="reference-1-1" URI="#xpointer(id('signed-data-1-1-1')/node())">
                    <dsig:Transforms>
                      <dsig:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#base64"/>
                    </dsig:Transforms>
                    <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                    <dsig:DigestValue>a53jOsL7KbyltpByAK87FoMZphI=</dsig:DigestValue>
                  </dsig:Reference>
                  <dsig:Reference Id="reference-1-5" URI="http://localhost:8080/referencedData/Text.b64">
                    <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                    <dsig:DigestValue>a53jOsL7KbyltpByAK87FoMZphI=</dsig:DigestValue>
                  </dsig:Reference>
                </dsig:Manifest>
              </dsig:Object>

Das fünfte `dsig:Object` enthält das `dsig:Manifest`, das von MOA SS auf Grund des ersten bzw. fünften `DataObjectInfo` des Requests erstellt wurde. Darin enthalten sind die zum ersten und fünten `DataObjectInfo` korrespondierenden `dsig:Reference` Elemente. Die Daten für die erste im `dsig:Manifest` enthaltene `dsig:Reference` wurden aus dem `Base64Content` Element des ersten `DataObjectInfo` entnommen, jene für die zweite `dsig:Reference` aus dem `Base64Content` Element des fünften `DataObjectInfo`. Der Wert des `URI` Attributs der zweiten `dsig:Reference` wurde aus dem `DataObject/@Reference` des fünften `DataObjectInfo` übernommen.

#### 2.1.2.3 Transformationen

##### Request

Dieses Beispiel (`CreateXMLSignatureRequest.Transforms.xml`) stellt die wichtigsten Transformationen vor, die von MOA SS bei der Erstellung einer Signatur verwendet werden können. Eine Transformation bzw. eine Kette mehrerer hintereinandergeschalteter Transformationen werden auf die Referenz-Eingangsdaten (also jene Daten, die in DataObjectInfo/DataObject angegeben werden) angewendet; das Ergebnis fließt dann in die Hashwert-Berechnung ein.

    <CreateXMLSignatureRequest
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <KeyIdentifier>KG_allgemein</KeyIdentifier>
      <SingleSignatureInfo SecurityLayerConformity="false">

Die Signatur soll mit dem Schlüssel `KG_allgemein` erstellt werden; jene Elemente, die speziell für eine Security-Layer V1.1 konforme Signatur notwendig sind (vergleiche Einfaches Beispiel), brauchen nicht erstellt zu werden (`SecurityLayerConformity="false"`).

        <DataObjectInfo Structure="detached">
          <DataObject Reference="http://localhost:8080/referencedData/Text.b64"/>
          <CreateTransformsInfoProfile>
            <CreateTransformsInfo>
              <dsig:Transforms>
                <dsig:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#base64"/>
              </dsig:Transforms>
              <FinalDataMetaInfo>
                <MimeType>text/plain</MimeType>
              </FinalDataMetaInfo>
            </CreateTransformsInfo>
          </CreateTransformsInfoProfile>
        </DataObjectInfo>

Für das erste zu signierende Datenobjekt werden die Referenz-Eingangsdaten mittels `DataObject/@Reference` referenziert, d. h. MOA SS löst die darin enthaltene URL auf, um zu den Daten zu gelangen. Es handelt sich dabei um einen base64 kodierten Text.

Unterschrieben werden soll nun aber nicht dieser base64 kodierte Text, sondern der entsprechend dekodierte Text. Dies lässt sich elegant durch die Angabe einer Base64 Decoding Transformation bewerkstelligen. Dazu wird als erstes Kindelement von `CreateTransformsInfo` ein `dsig:Transforms` Element im Request angegeben. Dieses `dsig:Transforms` Element nimmt ein oderer mehrere `dsig:Transform` Elemente auf, wobei jedes `dsig:Transform` Element für eine Transformation steht. In unserem Fall wird nur eine einzige Transformation benötigt; die Angabe, um welche Transformation es sich handelt, wird durch das Attribut `dsig:Transform/@Algorithm` angegeben. Für die Base64 Decoding Transformation muss der Wert auf `http://www.w3.org/2000/09/xmldsig#base64` gesetzt werden. Sie ist eine parameterlose Transformation, d. h. `dsig:Transform` hat keine Kindelemente.

Der Mime-Type der zu signierenden Daten wird als `text/plain` angegeben, da ja tatsächlich nach der durchgeführten Transformation dekodierter Text vorliegt, über den dann der Hashwert berechnet wird.

        <DataObjectInfo Structure="detached">
          <DataObject Reference="http://localhost:8080/referencedData/XMLDocument.xml"/>
          <CreateTransformsInfoProfile>
            <CreateTransformsInfo>
              <dsig:Transforms>
                <dsig:Transform Algorithm="http://www.w3.org/2002/06/xmldsig-filter2">
                  <xp2:XPath
                    xmlns:xp2="http://www.w3.org/2002/06/xmldsig-filter2"
                    xmlns:doc="urn:document"
                    Filter="subtract">/doc:XMLDocument/doc:Paragraph[2]</xp2:XPath>
                </dsig:Transform>
                <dsig:Transform Algorithm="http://www.w3.org/TR/1999/REC-xslt-19991116">
                  <xsl:stylesheet version="1.0"
                    xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:doc="urn:document">
      <xsl:output encoding="UTF-8" method="xml" indent="yes"/>
      <xsl:template match="/doc:XMLDocument">
        <html xmlns="http://www.w3.org/1999/xhtml">
          <head>
            <title>HTML-Dokument</title>
          </head>
          <body>
            <xsl:for-each select="doc:Paragraph">
              <p>
                <xsl:value-of select="child::text()"/>
              </p>
            </xsl:for-each>
          </body>
        </html>
      </xsl:template>
    </xsl:stylesheet></dsig:Transform>
                <dsig:Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
              </dsig:Transforms>
              <FinalDataMetaInfo>
                <MimeType>application/xhtml+xml</MimeType>
              </FinalDataMetaInfo>
            </CreateTransformsInfo>
          </CreateTransformsInfoProfile>
        </DataObjectInfo>

Für das zweite zu signierende Datenobjekt werden die Referenz-Eingangsdaten wiederum mittels `DataObject/@Reference` referenziert, d. h. MOA SS löst die darin enthaltene URL auf, um zu den Daten zu gelangen. Es handelt sich dabei um ein XML-Dokument.

Zunächst soll von diesem XML-Dokument jedoch ein Teil weggeschnitten werden, da er nicht mitsigniert werden soll. Für diesen Zweck bietet sich die XPath Filter 2 Transformation an. Das Attribut `dsig:Transform/@Algorithm` ist dazu auf den Wert `http://www.w3.org/2002/06/xmldsig-filter2` zu setzen. Diese Transformation benötigt weiters Transformationsparameter. Diese werden als Kindelement `xp2:XPath` in `dsig:Transform` angegeben. Das Attribut `Filter` selektiert den Filtermodus; für das Bespiel wird den Modus `subtract` benötigt, da ein Teil weggefiltert werden soll. Der Textinhalt von `xp2:XPath` ist ein XPath-Ausdruck, der den Wurzelknoten jenes Teilbaums selektiert, der weggefiltert werden soll. Für das Beispiel soll das zweite `doc:Paragraph` Element des XML-Dokuments weggefiltert werden. Beachten Sie, dass das im XPath-Ausdruck verwendete Namespace-Prefix `doc` im Kontext des `xp2:XPath` Elements deklariert sein muss.

Als nächstes soll nun das XML-Dokument mit Hilfe eines Stylesheets in ein XHTML-Dokument übergeführt werden. Dazu kann die XSLT Transformation verwendet werden. Das Attribut `dsig:Transform/@Algorithm` ist dazu auf den Wert `http://www.w3.org/TR/1999/REC-xslt-19991116` zu setzen. Auch diese Transformation benötigt Transformationsparameter: Als Kindelement von `dsig:Transform` wird jener Stylesheet angegeben, mit dem die Stylesheet-Transformation ausgeführt werden soll.

Abschließend soll, wie in der Spezifikation der XSLT-Transformation empfohlen, eine Kanonisierungstransformation angewendet werden. Damit können Unterschiede im Output unterschiedlicher XSLT-Engines, wie sie in der Praxis vorkommen, abgefangen werden. Beachten Sie, dass als Voraussetzung dazu die Output-Methode im Stylesheet auf `xml` festgelegt werden muss (`<xsl:output method="xml">`), denn nur XML-Output kann anschließend kanonisiert werden. Das Attribut `dsig:Transform/@Algorithm` ist für die Canonical XML Transformation auf den Wert http://www.w3.org/TR/2001/REC-xml-c14n-20010315 zu setzen. Die Transformation benötigt keine Transformationsparameter.

Das Ergebnis der drei hintereinandergeschalteten Transformationen, welches der Hashwert-Berechnung zufließt, finden Sie hier.

##### Response

`CreateXMLSignatureRequest.Transforms.resp.xml` ist eine typische Response des SS Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <CreateXMLSignatureResponse
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <SignatureEnvironment>
        <dsig:Signature Id="signature-1-1" xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
          <dsig:SignedInfo>
            <dsig:CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
            <dsig:SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha1"/>

Die Antwort enthält in `SignatureEnvironment` das Ergebnis der Signaturerstellung. Nachdem die Signatur in kein bestehendes Dokument eingefügt werden sollte, enhält `SignatureEnvironment` direkt die erzeugte XML-Signatur (`dsig:Signature`).

            <dsig:Reference Id="reference-1-1" URI="http://localhost:8080/referencedData/Text.b64">
              <dsig:Transforms>
                <dsig:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#base64"/>
              </dsig:Transforms>
              <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
              <dsig:DigestValue>a53jOsL7KbyltpByAK87FoMZphI=</dsig:DigestValue>
            </dsig:Reference>

Die erste `dsig:Reference` wurde auf Grund des ersten `DataObjectInfo` im Request erstellt. Man erkennt dass die URL auf die Referenz-Eingangsdaten (Wert des Attributs `dsig:Reference/@URI`) aus `DataObject/@Reference` übernommen und eine Base64 Decoding Transformation eingefügt würde. Die im Request spezifizierten Transformationen werden also eins zu eins in die XML-Signatur übernommen.

            <dsig:Reference Id="reference-1-2" URI="http://localhost:8080/referencedData/XMLDocument.xml">
              <dsig:Transforms>
                <dsig:Transform Algorithm="http://www.w3.org/2002/06/xmldsig-filter2">
                  <xp2:XPath Filter="subtract" xmlns:doc="urn:document"
                    xmlns:dsig="http://www.w3.org/2000/09/xmldsig#"
                    xmlns:xf2="http://www.w3.org/2002/06/xmldsig-filter2"
                    xmlns:xp2="http://www.w3.org/2002/06/xmldsig-filter2">/doc:XMLDocument/doc:Paragraph[2]</xp2:XPath>
                </dsig:Transform>
                <dsig:Transform Algorithm="http://www.w3.org/TR/1999/REC-xslt-19991116">
                  <xsl:stylesheet version="1.0"
                    xmlns:doc="urn:document" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
                    <xsl:output encoding="UTF-8" indent="yes" method="xml"/>
                    <xsl:template match="/doc:XMLDocument">...</xsl:template>
                  </xsl:stylesheet>
                </dsig:Transform>
                <dsig:Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
              </dsig:Transforms>
              <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
              <dsig:DigestValue>fIPwneCpjVqTXwHMN9DFfx6tJIU=</dsig:DigestValue>
            </dsig:Reference>

Die zweite `dsig:Reference` wurde auf Grund des zweiten `DataObjectInfo` im Request erstellt. Man erkennt auch hier gut, dass die URL auf die Referenz-Eingangsdaten (Wert des Attributs `dsig:Reference/@URI`) aus `DataObject/@Reference` übernommen und die drei Transformationen wie im Request angegeben eingefügt wurden.

#### 2.1.2.4 Ergänzungsobjekte

##### Request

Dieses Beispiel (`CreateXMLSignatureRequest.Supplements.xml`) stellt die Verwendung von Ergänzungsobjekten vor. Ein Ergänzungsobjekt betrifft entweder ein zu signierendes Datum (Zusammenhang mit einem `DataObject`) oder jenes Dokument, in das eine zu erzeugende Signatur eingefügt werden soll (Zusammenhang mit `CreateSignatureEnvironment`). Es muss dann angegeben werden, wenn in einem zu signierenden Datum bzw. im Einfügedokument auf Daten per Referenz verwiesen wird, diese referenzierten Daten aber von MOA SS nicht aufgelöst werden können. Das Ergänzungsobjekt enthält dann genau diese Daten, die nicht von MOA SS aufgelöst werden können.

    <CreateXMLSignatureRequest
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <KeyIdentifier>KG_allgemein</KeyIdentifier>
      <SingleSignatureInfo SecurityLayerConformity="false">

Die Signatur soll mit dem Schlüssel `KG_allgemein` erstellt werden; jene Elemente, die speziell für eine Security-Layer V1.1 konforme Signatur notwendig sind (vergleiche Einfaches Beispiel), brauchen nicht erstellt zu werden (`SecurityLayerConformity="false"`).

        <DataObjectInfo Structure="detached">
          <DataObject Reference="#Para2"/>

Das zu signierende Datum in diesem Beispiel ist ein Teil des Dokuments, in das die zu erstellende Signatur eingefügt werden soll. Der Wert des `Reference` Attributs ist `#Para2`, das bedeutet, dass jenes Element des Einfügedokuments signiert werden soll, das ein ID-Attribut mit dem Wert `#Para2` aufweist. Damit MOA SS diesen Hinweis auswerten kann, muss es das Einfügedokument validierend parsen, denn sonst wüsste es ja nicht, welche Attribute überhaupt ID-Attribute sind. Das zum validierenden Parsen notwendige XML-Schema wird MOA SS in diesem Beispiel über ein Ergänzungsobjekt zum Einfügedokument mitgeteilt (siehe weiter unten).

          <CreateTransformsInfoProfile>
            <CreateTransformsInfo>
              <dsig:Transforms>
                <dsig:Transform Algorithm="http://www.w3.org/TR/1999/REC-xslt-19991116">
                  <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
      <xsl:include href="XMLDocument.Para.xsl"/>
    </xsl:stylesheet>
                </dsig:Transform>
                <dsig:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
              </dsig:Transforms>
              <FinalDataMetaInfo>
                <MimeType>application/xhtml+xml</MimeType>
              </FinalDataMetaInfo>

Das Beispiel enthält als erste Transformation eine XSLT-Transformation. Der als Kindelement von `dsig:Transform` angegebene Stylesheet verweist dabei mittels `xsl:include` auf einen weiteren Stylesheet. Dieser weitere Stylesheet kann jedoch von MOA nicht direkt aufgelöst werden, da er als relative Referenz angegeben wird. Deshalb ist es notwendig, diesen weiteren Stylesheet als Ergänzungsobjekt zu den signierenden Daten anzugeben:

< </CreateTransformsInfo> <Supplement> <Content Reference="XMLDocument.Para.xsl"> <LocRefContent>http://localhost:8080/referencedData/XMLDocument.Para.xsl</LocRefContent> </Content> </Supplement> </CreateTransformsInfoProfile> </DataObjectInfo>

Ein Ergänzungsobjekt für zu signierende Daten wird im entsprechenden `DataObjectInfo` Element angegeben, und zwar als Inhalt des Elements `CreateTransformsInfoProfile/Supplement`. Das verpflichtend zu verwendende Attribut `Content/@Reference` enthält dabei die Referenz auf das Ergänzungsobjekt in exakt jener Schreibweise, wie sie in der `xsl:include` Direktive vorkommt, hier also `XMLDocument.Para.xsl`. Das Element `Content` beinhaltet das Ergänzungsobjekt so, wie es MOA SS verwenden soll (Elemente `Base64Content` oder `XMLContent`, vergleiche Einfaches Beispiel), bzw. enthält eine von MOA SS auflösbare Referenz auf das Ergänzungsobjekt (Element `LocRefContent`, vergleiche Einfaches Beispiel). Im konkreten Beispiel wird `LocRefContent` verwendet.

        <CreateSignatureInfo>
          <CreateSignatureEnvironment
            Reference="http://localhost:8080/referencedData/XMLDocument.withSchemaHint.xml"/>
          <CreateSignatureEnvironmentProfile>
            <CreateSignatureLocation
              Index="4" xmlns:doc="urn:document">/doc:XMLDocument</CreateSignatureLocation>

Eingefügt werden soll die zu erzeugende Signatur in ein bestehendes Dokument, das MOA SS durch Auflösen der in `CreateSignatureEnvironment/@Reference` angegebenen URL erhält. Eingefügt werden soll die Signatur als fünfter Kindknoten des Wurzelelements `doc:XMLDocument`. Beachten Sie wiederum die Hinweise zur Zählweise für das Attribut `Index` bzw. zur Deklaration der im XPath-Ausdruck verwendeten Namespace-Deklarationen (hier `doc`).

            <Supplement>
              <Content Reference="urn:XMLDocument.xsd">
                <LocRefContent>http://localhost:8080/referencedData/XMLDocument.xsd</LocRefContent>
              </Content>
            </Supplement>
          </CreateSignatureEnvironmentProfile>
        </CreateSignatureInfo>

Wie oben bereits angemerkt, muss MOA SS zur Auflösung der ID-Referenz `#Para2` das Einfügedokument validierend parsen. Im Einfügedokument ist zwar nun ein Hinweis auf die dazu notwendige Grammatikinformation in Form eines XML-Schemas enthalten (Attribut `xsi:schemaLocation` enthält den Wert `"urn:document urn:XMLDocument.xsd"`). Nachdem die darin angegebene URI `urn:XMLDocument.xsd` jedoch von MOA nicht direkt aufgelöst werden kann, wird im Request ein Ergänzungsobjekt zum Einfügedokument angegeben (`CreateSignatureEnvironmentProfile/Supplement`). Das Attribut `Content/@Reference` enthält die Referenz auf das Ergänzungsobjekt in exakt jener Schreibweise, wie sie im Attribut `xsi:schemaLocation` angegeben wurde (`urn:XMLDocument.xsd`). Das Element `Content` beinhaltet das Ergänzungsobjekt so, wie es MOA SS verwenden soll (Elemente `Base64Content` oder `XMLContent`, vergleiche Einfaches Beispiel), bzw. enthält eine von MOA SS auflösbare Referenz auf das Ergänzungsobjekt (Element `LocRefContent`, vergleiche Einfaches Beispiel). Im konkreten Beispiel wird `LocRefContent` verwendet.

Beachten Sie bitte, dass die Verwendung von Ergänzungsobjekten für die Mitteilung von XML-Schemata nur dann funktioniert, wenn die Referenz auf das XML-Schema in der `xsi:schemaLocation` eine absolute URI ist (also z.B. wie hier `urn:XMLDocument.xsd` oder auch `http://example.org/XMLDocument.xsd`, nicht aber z.B. `XMLDocument.xsd` oder `../schemas/XMLDocument.xsd`).

Auch für das Auflösen eines Verweises in einer DTD kann in analoger Weise von Ergänzungsobjekten Gebrauch gemacht werden.

##### Response

`CreateXMLSignatureRequest.Supplements.resp.xml` ist eine typische Response des SS Webservices auf den obigen Request. Er wird an dieser Stelle nicht näher analysiert, da er keine für das Thema des Beispiels relevanten Besonderheiten aufweist.

### 2.1.3 Prüfung einer CMS bzw. CAdES-Signatur

#### 2.1.3.1 Einfaches Beispiel

##### Request

Dieses Beispiel (`VerifyCMSSignatureRequest.Simple.xml`) ist ein einfacher Request zur Prüfung einer CMS-Signatur. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass der nachfolgende Ausschnitt aus dem Request aus Gründen der Übersichtlichkeit gekürzt wurde.

    <VerifyCMSSignatureRequest
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#">
      <CMSSignature>MIIHsAYJKo...4sLL6kpOPJaLg==</CMSSignature>
      <TrustProfileID>Test-Signaturdienste</TrustProfileID>
    </VerifyCMSSignatureRequest>

Der Request enthält zunächst in `CMSSignature` die zu prüfende CMS-Signatur, und zwar in base64 kodierter Form. In diesem Beispiel wird davon ausgegangen, dass es sich dabei um eine Enveloping Signature handelt, d. h. dass die signierten Daten als Teil der CMS-Struktur vorhanden sind. Für die Behandlung einer Detached Signature sei auf das nächste Beispiel verwiesen.

Abschließend enthält der Request in `TrustProfileID` die Angabe des Vertrauensprofils, gegen das die Vertrauensprüfung des Zertifikats durchgeführt werden soll. Ein Vertrauensprofil mit dem angegebenen Namen muss in der für die Signaturprüfung verwendeten Instanz von MOA SP eingerichtet sein.

##### Response

`VerifyCMSSignatureRequest.Simple.resp.xml` ist eine typische Response des SP Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyCMSSignatureResponse
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <SignerInfo>
        <dsig:X509Data>
          <dsig:X509SubjectName>serialNumber=615536615920,givenName=Gregor,SN=Karlinger,
    CN=Gregor Karlinger,C=AT</dsig:X509SubjectName>
          <dsig:X509IssuerSerial>
            <dsig:X509IssuerName>CN=TrustSignTest-Sig-01,OU=TrustSignTest-Sig-01,
    O=A-Trust Ges. für Sicherheitssysteme im elektr. Datenverkehr GmbH,C=AT</dsig:X509IssuerName>
            <dsig:X509SerialNumber>2892</dsig:X509SerialNumber>
          </dsig:X509IssuerSerial>
          <dsig:X509Certificate>...</dsig:X509Certificate>
          <QualifiedCertificate/>
        </dsig:X509Data>
      </SignerInfo>

Die Response enthält zunächst in `SignerInfo/dsig:X509Data` Informationen über den Signator, die aus dem in der CMS-Signatur enthaltenen Signatorzertifikat entnommen sind.

`dsig:X509SubjectName` ist immer vorhanden und enthält den Namen des Signators. `dsig:X509IssuerSerial` ist ebenfalls immer vorhanden und enthält den Namen des Austellers des Signatorzertifikats (`dsig:X509IssuerName`) sowie die Seriennummer des Zertifikats (`dsig:X509SerialNumber`). Auch `dsig:X509Certificate` ist immer vorhanden und enthält das Signatorzertifikat in base64 kodierter Form.

Optional vorhanden ist das inhaltslose Element `QualifiedCertificate`, und zwar dann, wenn es sich beim Signatorzertifikat um ein qualifiziertes Zertifikat handelt. Ebenfalls optional vorhanden ist schließlich - in diesem Beispiel nicht ersichtlich - das Element `PublicAuthority`, und zwar dann, wenn das Signatorzertifikat die österreichspezifische Zertifikatserweiterung Verwaltungseigenschaft aufweist. Ist in dieser Zertifikatserweiterung das Verwaltungskennzeichen mitkodiert, wird dieses Kennzeichen als Textinhalt des optionalen Elements `PublicAuthority/Code` geliefert.

      <SignatureCheck>
        <Code>0</Code>
      </SignatureCheck>

Anschließend an `SignerInfo` enthält die Response mit `SignatureCheck/Code` das Resultat der kryptographischen Prüfung der Signatur. In unserem Beispiel ist dort der Wert `0` enthalten, d. h. die Signatur konnte erfolgreich validiert werden. Für eine Übersicht der möglichen Kodes zur Signaturprüfung finden Sie in der nachstehenden Tabelle und diese entsprechen auch der Security-Layer Spezifikation.

SignatureCheck/Code | Beschreibung
0 | Die Überprüfung des Werts der Signatur konnte erfolgreich durchgeführt werden (entspricht sl:code 0)
1 | Bei der Überprüfung des Werts der Signatur ist ein Fehler aufgetreten. (entspricht sl:code 1)
2 | Keine Signatur gefunden oder die Signatur konnte technisch nicht verarbeitet werden

      <CertificateCheck>
        <Code>1</Code>
      </CertificateCheck>

Abschließend enthält die Response mit `CertificateCheck/Code` das Resultat der Prüfung des Signatorzertifikats. Zunächst prüft MOA SP, ob ausgehend vom Signatorzertifikat eine Zertifikatskette zu einem im zugehörigen Vertrauensprofil konfigurierten sog. Trust Anchor gebildet werden kann. Gelingt dies, wird die Gültigkeit jedes Zertifikats dieser Kette überprüft. In unserem Beispiel enthält `Code` den Wert `1`, d. h. MOA SP konnte die oben erläuterte Zertifikatskette nicht bilden. Für eine Übersicht der möglichen Kodes siehe Security-Layer Spezifikation.

#### 2.1.3.2 Erweitertes Beispiel

##### Request

Dieses erweiterte Beispiel zur Prüfung einer CMS-Signatur (`VerifyCMSSignatureRequest.Extended.xml`) demonstriert die Prüfung mehrerer Signatoren einer CMS-Signatur, die Angabe des Prüfzeitpunkts sowie die Prüfung einer Detached Signature, d. h. einer Signatur, in der die signierten Daten nicht enthalten sind und daher extra angegeben werden müssen.

    <VerifyCMSSignatureRequest
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      Signatories="1">
      <DateTime>2004-08-17T08:00:00+02:00</DateTime>
    	<ExtendedValidation>false</ExtendedValidation>
      <CMSSignature>MIIHiwYJKoZI...kfiwsvqSk48lou</CMSSignature>
      <DataObject>
        <Content>
          <Base64Content>RGllc2UgRGF0ZW4gd2FyZW4gYmFzZTY0IGtvZGllcnQu</Base64Content>
        </Content>
      </DataObject>
      <TrustProfileID>Test-Signaturdienste</TrustProfileID>
    </VerifyCMSSignatureRequest>

Liegt eine zu prüfende CMS-Signatur vor, die von mehreren Unterzeichnenden signiert worden ist, kann das Attribut `VerifyCMSSignatureRequest/@Signatories` verwendet werden, um jene Unterzeichnenden auszuwählen, deren Unterschriften von MOA SP geprüft werden sollen. Der Default-Wert für dieses optionale Attribut ist `1`. Soll nicht die Unterschrift allein des ersten Unterzeichnenden geprüft werden, muss das Attribut explizit angegeben werden. Es enthält dann eine oder mehrere Ganzzahlwerte, getrennt durch Leerzeichen. Jede Ganzzahl bezeichnet einen Unterzeichnenden, wobei die Reihenfolge der Auflistung der Unterzeichner in der CMS-Signatur entspricht. Der Wert `"1 3"` würde beispielsweise aussagen, dass MOA SP die Unterschrift des ersten sowie des dritten Unterzeichnenden prüfen soll.

Mit dem optionalen Element `DateTime` kann der Zeitpunkt der Signaturprüfung explizit vorgegeben werden. Inhalt dieses Elements ist die Angabe von Datum und Uhrzeit entsprechend dem XML-Schema Datentyp dateTime. Enthält der angegebene Zeitpunkt keinen Zeitzonen-Offset zur UTC, wird der Zeitpunkt als lokale Zeit des Servers interpretiert, auf dem MOA SP läuft. Wird `DateTime` nicht angegeben, versucht MOA SP, den Zeitpunkt der Signaturerstellung aus der Signatur zu ermitteln (anhand des Signaturattributs SigningTime). Enthält die Signatur keinen Zeitpunkt der Signaturerstellung, verwendet MOA SP die aktuelle Systemzeit des Servers, auf dem es läuft. Das optionale Element `ExtendedValidation` kann dafür genutzt werden den Formvalidierungsmodus für CAdES Signaturen zu aktivieren. Diesem Fall enthält die Response spezifische Informationen bezüglich des CAdES Profils der Signatur und erweiterte Zertifikatsprüfungsergebnisse. Detailinformationen zu den erweiterten Ergebnissen finden Sie im Abschnitt 2.1.4.2, da diese für alle unterstützen Signaturformate identisch sind.

Das optionale Element `DataObject` muss dann angegeben werden, wenn eine Detached Signature geprüft werden soll, d. h. wenn in der CMS-Signatur die signierten Daten nicht mitkodiert sind. In `DataObject/Content/Base64Content` sind in einem solchen Fall diese Daten in base64 kodierter Form bereit zu stellen.

##### Response

`VerifyCMSSignatureRequest.Extended.resp.xml` ist eine typische Response des SP Webservices auf den obigen Request. Er wird an dieser Stelle nicht näher analysiert, da er keine für das Thema des Beispiels relevanten Besonderheiten aufweist.

### 2.1.4 Prüfen einer XML-Signatur

#### 2.1.4.1 Einfaches Beispiel

##### Request

`VerifyXMLSignatureRequest.Simple.xml` ist ein einfacher XML-Request zur Prüfung einer XML-Signatur. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass der dargestellte Request zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyXMLSignatureRequest xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#">
      <VerifySignatureInfo>
        <VerifySignatureEnvironment>
          <XMLContent>
            <dsig:Signature Id="signature-1-1" xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
              <dsig:SignedInfo>
                <dsig:CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
                <dsig:SignatureMethod
                  Algorithm="http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha1"/>
                <dsig:Reference Id="reference-1-1" URI="#xpointer(id('signed-data-1-1-1')/node())">
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>tLODyeiWFbAkQKwhrR23jtcgu4k=</dsig:DigestValue>
                </dsig:Reference>
              </dsig:SignedInfo>
              <dsig:SignatureValue>...</dsig:SignatureValue>
              <dsig:KeyInfo>...</dsig:KeyInfo>
              <dsig:Object Id="signed-data-1-1-1">Diese Daten werden signiert.</dsig:Object>
            </dsig:Signature>
          </XMLContent>
        </VerifySignatureEnvironment>

Das Element `VerifySignatureEnvironment` enthält jenes XML-Dokument, das die zu prüfende XML-Signatur enthält. Auch hier stehen eine Reihe von Möglichkeiten zur Verfügung, dieses XML-Dokument anzugeben. Im Beispiel wurde das Element `XMLContent` verwendet; alternativ stehen die Elemente `Base64Content` und `LocRefContent` bzw. gleichwertig zu `LocRefContent` das Attribut `Reference` zur Verfügung.

Im konkreten Beispiel enthält das angegebene XML-Dokument direkt als Root-Element die zu prüfende Signatur (`dsig:Signature`). Es handelt sich dabei um eine Enveloping Signature, d. h. die signierten Daten sind in einem `dsig:Object` als Teil der XML-Struktur der Signatur kodiert. Tatsächlich signiert ist hier die Zeichenkette `Diese Daten werden signiert.`

        <VerifySignatureLocation
          xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">/dsig:Signature</VerifySignatureLocation>
      </VerifySignatureInfo>

Das Element `VerifySignatureLocation` enthält als Text den XPath-Ausdruck zur Selektion der XML-Signatur innerhalb des zu prüfenden XML-Dokuments. Die Auswertung des XPath-Ausdrucks muss genau ein Element `dsig:Signature` ergeben. Bitte beachten Sie, dass im Kontext des Elements `VerifySignatureLocation` alle im XPath-Ausdruck verwendeten Namespace-Präfixe bekannt sein müssen (hier das Präfix `dsig`).

      <TrustProfileID>Test-Signaturdienste</TrustProfileID>
    </VerifyXMLSignatureRequest>

Das Element `TrustProfileID` schließlich enthält den Bezeichner des Vertrauensprofils, gegen das die Zertifikatsprüfung von MOA SP durchgeführt wird. Ein Vertrauensprofil enthält die Zertifikate jene Zertifizierungsdiensteanbieter, denen als Aussteller von Signatorzertifikaten vertraut wird. Ein Vertrauensprofil mit dem gewählten Namen (hier `Test-Signaturdienste`) muss in der Konfiguration von MOA SP hinterlegt sein.

##### Response

`VerifyXMLSignatureRequest.Simple.resp.xml` ist eine typische Response des SP Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyXMLSignatureResponse
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <SignerInfo>
        <dsig:X509Data>
          <dsig:X509SubjectName>CN=Test: Signaturdienst aller Kunden: ECDSA (P192v1),OU=Technik und Standards,
          O=Stabsstelle IKT-Strategie des Bundes,C=AT</dsig:X509SubjectName>
          <dsig:X509IssuerSerial>
            <dsig:X509IssuerName>CN=Test CA - Signaturdienste,OU=Technik und Standards,
            O=Stabstelle IKT-Strategie des Bundes,C=AT</dsig:X509IssuerName>
            <dsig:X509SerialNumber>9</dsig:X509SerialNumber>
          </dsig:X509IssuerSerial>
          <dsig:X509Certificate>...</dsig:X509Certificate>
          <PublicAuthority>
            <Code>BKA-IKT</Code>
          </PublicAuthority>
        </dsig:X509Data>
      </SignerInfo>

Die Response enthält zunächst in `SignerInfo/dsig:X509Data` Informationen über den Signator, die aus dem in der XML-Signatur enthaltenen Signatorzertifikat entnommen sind.

`dsig:X509SubjectName` ist immer vorhanden und enthält den Namen des Signators. `dsig:X509IssuerSerial` ist ebenfalls immer vorhanden und enthält den Namen des Austellers des Signatorzertifikats (`dsig:X509IssuerName`) sowie die Seriennummer des Zertifikats (`dsig:X509SerialNumber`). Auch `dsig:X509Certificate` ist ist immer vorhanden und enthält das Signatorzertifikat in base64 kodierter Form.

Optional vorhanden - in diesem Beispiel nicht ersichtlich - ist das inhaltslose Element `QualifiedCertificate`, und zwar dann, wenn es sich beim Signatorzertifikat um ein qualifiziertes Zertifikat handelt. Ebenfalls optional vorhanden ist schließlich das Element `PublicAuthority`, und zwar dann, wenn das Signatorzertifikat die österreichspezifische Zertifikatserweiterung Verwaltungseigenschaft aufweist. Ist in dieser Zertifikatserweiterung das Verwaltungskennzeichen mitkodiert, wird dieses Kennzeichen als Textinhalt des optionalen Elements `PublicAuthority/Code` geliefert.

      <SignatureCheck>
        <Code>0</Code>
      </SignatureCheck>

Anschließend an `SignerInfo` enthält die Response mit `SignatureCheck/Code` das Resultat der kryptographischen Prüfung der Signatur. In unserem Beispiel ist dort der Wert `0` enthalten, d. h. die Signatur konnte erfolgreich validiert werden. Für eine Übersicht der möglichen Kodes siehe Security-Layer Spezifikation.

      <CertificateCheck>
        <Code>0</Code>
      </CertificateCheck>

Abschließend enthält die Response mit `CertificateCheck/Code` das Resultat der Prüfung des Signatorzertifikats. Zunächst prüft MOA SP, ob ausgehend vom Signatorzertifikat eine Zertifikatskette zu einem im zugehörigen Vertrauensprofil konfigurierten sog. Trust Anchor gebildet werden kann. Gelingt dies, wird die Gültigkeit jedes Zertifikats dieser Kette überprüft. In unserem Beispiel enthält `Code` den Wert `0`, d. h. MOA SP konnte die Kette bilden, und alle Zertifikate der Kette sind gültig. Für eine Übersicht der möglichen Kodes siehe Security-Layer Spezifikation.

#### 2.1.4.2 Erweitertes Beispiel

##### Request

Dieses erweiterte Beispiel zur Prüfung einer XML-Signatur (`VerifyXMLSignatureRequest.Enveloped.xml`) demonstriert die Prüfung einer Enveloped Signature, d. h. einer Signatur, die in ein XML-Dokument integriert ist, die Angabe des Prüfzeitpunkts sowie die Anweisung an MOA SP, in der Response die von der Signatur abgedeckten Daten zu retournieren.

    <VerifyXMLSignatureRequest xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#">
      <DateTime>2004-08-18T17:00:00+02:00</DateTime>
    	<ExtendedValidation>true</ExtendedValidation>

Mit dem optionalen Element `DateTime` kann der Zeitpunkt der Signaturprüfung explizit vorgegeben werden. Inhalt dieses Elements ist die Angabe von Datum und Uhrzeit entsprechend dem XML-Schema Datentyp dateTime. Enthält der angegebene Zeitpunkt keinen Zeitzonen-Offset zur UTC, wird der Zeitpunkt als lokale Zeit des Servers interpretiert, auf dem MOA SP läuft. Wird `DateTime` nicht angegeben, versucht MOA SP, den Zeitpunkt der Signaturerstellung aus der Signatur zu ermitteln (anhand des Signaturattributs SigningTime). Enthält die Signatur keinen Zeitpunkt der Signaturerstellung, verwendet MOA SP die aktuelle Systemzeit des Servers, auf dem es läuft. Das optionale Element `ExtendedValidation` kann dafür genutzt werden den Formvalidierungsmodus für XAdES Signaturen zu aktivieren. Diesem Fall enthält die Response spezifische Informationen bezüglich des XAdES Profils der Signatur und erweiterte Prüfungsergebnisse.

      <VerifySignatureInfo>
        <VerifySignatureEnvironment Reference="http://localhost:8080/referencedData/XMLDocument.signed.xml"/>
        <VerifySignatureLocation xmlns:doc="urn:document"
          xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">/doc:XMLDocument/dsig:Signature</VerifySignatureLocation>
      </VerifySignatureInfo>

Das Element `VerifySignatureEnvironment` enthält in diesem Fall mit dem Attribut `Reference` eine Referenz auf das XML-Dokument (`XMLDocument.signed.xml`), das die zu prüfende Signatur beinhaltet. Als Textinhalt von `VerifySignatureLocation` ist ein XPath-Ausdruck angegeben, der die zu prüfende Signatur innerhalb des XML-Dokuments auswählt. Bitte beachten Sie, dass im Kontext des Elements `VerifySignatureLocation` alle im XPath-Ausdruck verwendeten Namespace-Präfixe bekannt sein müssen (hier die Präfixe `doc` und `dsig`).

      <ReturnHashInputData/>
      <TrustProfileID>Test-Signaturdienste</TrustProfileID>
    </VerifyXMLSignatureRequest>

Durch Angabe des optionalen, leeren Elements `ReturnHashInputData` wird MOA SP angewiesen, im Response jene Daten zurückzuliefern, die von der Signatur abgedeckt sind, d. h. tatsächlich signiert wurden (siehe unten). Diese Information ist für die MOA SP verwendende Anwendung essentiell, da sie wissen muss, ob tatsächlich die von ihr geforderten Daten signiert wurden. Wird `HashInputData` im Request nicht angegeben, muss die Anwendung selbst die Signatur analysieren, um diese Information zu erhalten.

##### Response

`VerifyXMLSignatureRequest.Enveloped.resp.xml` ist eine typische Response des SP Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyXMLSignatureResponse
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <SignerInfo>
        <dsig:X509Data>...</dsig:X509Data>
      </SignerInfo>

Die Response enthält zunächst in `SignerInfo/dsig:X509Data` Informationen über den Signator, die aus dem in der XML-Signatur enthaltenen Signatorzertifikat entnommen sind (siehe Einfaches Beispiel).

      <HashInputData HashAlgorithm="SHA-256" PartOf="SignedInfo">
        <Base64Content>PGRvYzp...hNTERvY3VtZW50Pg==</Base64Content>
      </HashInputData>

Wurde im Request - so wie in diesem Beispiel - das Element `ReturnHashInputData` angegeben, enthält die Response nach `SignerInfo` für jede `dsig:Reference` in `dsig:SignedInfo` der XML-Signatur (bzw. auch für jede `dsig:Reference` aus einem `dsig:Manifest`, auf das mittels des Attributs `Type="http://www.w3.org/2000/09/xmldsig#Manifest"` in einer `dsig:Reference` aus `dsig:SignedInfo` verwiesen wird; solche Manifeste kommen aber in diesem Beispiel nicht vor) ein Element `HashInputData`.

Die Reihenfolge der `HashInputData`-Elemente entspricht der Reihenfolge der `dsig:Reference`-Elemente in `dsig:SignedInfo` der XML-Signatur (enthält die XML-Signatur auch `dsig:Manifest`-Elemente, auf die jeweils in einer `dsig:Reference` aus `dsig:SignedInfo` verwiesen wird, werden zuerst `HashInputData`-Elemente für alle `dsig:Reference`-Elemente aus `dsig:SignedInfo` und anschließend `HashInputData`-Elemente für alle `dsig:Reference`-Elemente aus den einzelnen `dsig:Manifest`-Elementen geliefert).

Das Attribut PartOf weist mit dem Wert SignedInfo darauf hin, dass die `dsig:Reference`, für welche die Hasheingangsdaten gelten, Teil von `dsig:SignedInfo` ist (für eine `dsig:Reference` aus einem `dsig:SignedInfo` würde der gelieferte Wert `XMLDSIGManifest` lauten; weiters würde`HashInputData` in einem solchen Fall ein weiteres Attribut `ReferringSigReference` aufweisen, dessen Wert die Nummer jener `dsig:Reference` aus `dsig:SignedInfo` als positive Ganzzahl repräsentiert, die auf das beinhaltende `dsig:Manifest` verweist.).

Der Inhalt wird dabei stets mittels `Base64Content` in base64-kodierter Form geliefert.

    <SignatureAlgorithm>SHA256withECDSA</SignatureAlgorithm>

Wird im Request der `ExtendedValidation` Modus aktiviert, beinhaltet die Response den verwendeten Signaturalgorithmus im Element `SignatureAlgorithm`.

      <SignatureCheck>
        <Code>0</Code>
      </SignatureCheck>
      <CertificateCheck>
        <Code>0</Code>
      </CertificateCheck>
    	<FormCheckResult>
    		<Code>0</Code>
    		<Name>B-LTA</Name>
    	</FormCheckResult>
    	<FormCheckResult>
    		<Code>0</Code>
    		<Name>B-LT</Name>
    	</FormCheckResult>
    	<FormCheckResult>
    		<Code>0</Code>
    		<Name>B-T</Name>
    	</FormCheckResult>
    	<FormCheckResult>
    		<Code>0</Code>
    		<Name>B-B</Name>
    	</FormCheckResult>
    	<ExtendedCertificateCheck>
    		<Major>
    			<Code>0</Code>
    			<Name>VALID</Name>
    		</Major>
    		<Minor>
    			<Code>23</Code>
    			<Name>SUCCESS</Name>
    		</Minor>
    	</ExtendedCertificateCheck>
    </VerifyXMLSignatureResponse>

Die Elemente `SignatureCheck` und `CertificateCheck` enthalten die Resultate der kryptographischen Prüfung der Signatur sowie der Zertifikatsprüfung (siehe Einfaches Beispiel). Die Elemente `FormCheckResult` enthalten die Ergebnisse zu den einzelnen Formvalidierungen und das Element `ExtendedCertificateCheck` enthalten die Ergebnisse zum erweiterten Zertifikatscheck.

Das Element `FormCheckResult` kann mehrfach vorkommen und beinhaltet die Validierungsergebnisse der folgenden erweiterten Signaturformate:

Name | Beschreibung
B-B | B- Level Conformance
B-T | T- Level Conformance.
B-LT | LT- Level Conformance
B-LTA | LTA- Level Conformance

Das Prüfergebnis des jeweiligen Levels wird in Form eines `Code` Elements zurückgegeben. Hierbei sind folgende Statuscodes möglich:

Code | Beschreibung
0 | Die Signatur entspricht der im Element`Name` angegebenen Form.
1 | Die Signatur beinhaltet alle Eigenschaften der im Element `Name` angegebenen Form. Bei der Validierung einer Eigenschaft trat jedoch ein Fehler auf. Hinweis: Ein exemplarisches Beispiel für einen solchen Validierungsfehler ist ein ungültiges keyUsage Attribute im Signaturzertifikat.
2 | Die Signatur beinhaltet nicht alle erforderlichen Eigenschaften der im Element`Name` angegebenen Form.
3 | Die Formvalidierung wurde wegen eines Fehlers abgebrochen

Details zu den einzelen Levels finden Sie in den entsprechenden Spezifikation:

- http://www.etsi.org/deliver/etsi_ts/103100_103199/103171/02.01.01_60/ts_103171v020101p.pdf
- http://www.etsi.org/deliver/etsi_ts/103100_103199/103172/02.01.01_60/ts_103172v020101p.pdf
- http://www.etsi.org/deliver/etsi_ts/102700_102799/10277804/01.01.02_60/ts_10277804v010102p.pdf

Das Element`ExtendedCertificateCheck` kommt einfach vor und beinhaltet die Validierungsergebnisse des erweiterten Zertifikatschecks. Hierbei sind die Validierungsergebnisse in ein `Major` und in ein `Minor` Ergebnis aufgetrennt wobei diese als gleichnamige XML Elemente abgebildet sind. Jedes dieser XML Elemnte beinhalet einen ResultCode als Element `Code` und ein eine optionale textuelle Beschreibung des Codes im Element `Name.`

Als Major Result sind folgende Codes möglich:

Code | Name | Beschreibung
0 | VALID | Extended Validierung erfolgreich
1 | INVALID | Extended Validierung nicht erfolgreich.
2 | INDETERMINATE | Ergebnis der extended Validierung ist aktuell nicht eindeutig ermittelbar, da zum Prüfzeitpunkt nicht alle Quellen erreichbar oder validierbar waren.
3 | SKIPPED | Extended Validierung nicht durchgeführt
4 | ERROR | Allgemeiner Fehler während der extended Validierung

Als Minor Result sind folgende Codes möglich:

Code | Beschreibung
0 | Ein Zertifikat ist als revokiert gekennzeichnet
1 | Hash Fehler
2 | Signaturüberprüfung fehlgeschlagen
3 | Richtlinien zur Signaturerstellung
4 | Richtlinien zur Zertifikatskettenbildung
5 | Richtlinien zu kryptografischen Verfahren
6 | Ein Zertifikat ist abgelaufen
7 | Ein Zertifikat ist noch nicht gültig
8 | Formatfehler
9 | Policy konnte nicht verarbeitet werden
10 | Unbekannter Commitment Type
11 | Timestamp Fehler
12 | Allgemeiner Fehler bei der Validierung
13 | Kein Signaturzertifikat gefunden
14 | Keine Zertifikatskette gefunden
15 | Keine Policy gefunden
16 | Revokiert und kein Proof of Existence (POE)
17 | CA Revokiert und kein Proof of Existence (POE)
18 | Proof of Existence (POE) ungültig
19 | Krypografische Anforderungen an Proof of Existence (POE)
20 | Proof of Existence (POE) nicht vorhanden
21 | Die Prüfung war zum aktuellen Zeitpunkt nicht erfolgreich. Eine erneute Prüfung zu einen späteren Zeitpunkt könnte jedoch ein anderes Ergebnis liefern.
22 | SignedData Element nicht gefunden
23 | Erfolgreich
24 | Fehler
25 | Die PAdES Signatur verwendet einen unbekannter SubFilter und kann somit nicht validiert werden.

#### 2.1.4.3 Prüfung eines XMLDSIG-Manifests

##### Request

Dieses Beispiel zur Prüfung einer XML-Signatur (`VerifyXMLSignatureRequest.XMLDSigManifest.xml`) demonstriert die Prüfung eines in der XML-Signatur vorhandenden Manifests nach XMLDSig. Bitte beachten Sie, dass der dargestellte Request zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyXMLSignatureRequest
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <VerifySignatureInfo>
        <VerifySignatureEnvironment>
          <XMLContent>
            <dsig:Signature xmlns:dsig="http://www.w3.org/2000/09/xmldsig#" Id="signature-1-1">
              <dsig:SignedInfo>
                <dsig:CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
                <dsig:SignatureMethod
                  Algorithm="http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha1"/>
                <dsig:Reference Type="http://www.w3.org/2000/09/xmldsig#Manifest" URI="#dsig-manifest-1-1">
                  <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                  <dsig:DigestValue>nUUaW6OtcsNvV/QhqmkU2QXT1Mw=</dsig:DigestValue>
                </dsig:Reference>
              </dsig:SignedInfo>
              <dsig:SignatureValue>315gCwZI...OXFwr+</dsig:SignatureValue>
              <dsig:KeyInfo>...</dsig:KeyInfo>
              <dsig:Object Id="signed-data-1-1-1">Diese Daten sind signiert.</dsig:Object>
              <dsig:Object>
                <dsig:Manifest Id="dsig-manifest-1-1">
                  <dsig:Reference Id="reference-1-1" URI="#xpointer(id('signed-data-1-1-1')/node())">
                    <dsig:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
                    <dsig:DigestValue>EYxznGxNRAIcHQeUsj+zsK+uaHA=</dsig:DigestValue>
                  </dsig:Reference>
                </dsig:Manifest>
              </dsig:Object>
            </dsig:Signature>
          </XMLContent>
        </VerifySignatureEnvironment>

Das Element `VerifySignatureEnvironment` enthält als `XMLContent` die zu prüfende XML-Signatur. Man erkennt, dass sich die einzige `dsig:Reference` im `dsig:SignedInfo` der XML-Signatur auf ein Manifest nach XMLDSig bezieht (erkennbar am Attribut `Type`, das auf den Wert `http://www.w3.org/2000/09/xmldsig#Manifest` gesetzt ist). Im Response (siehe unten) werden wir deshalb ein eigenes Resultat für die Manifest-Prüfung erhalten.

Das Manifest selbst ist in einem `dsig:Object`, also innerhalb der XML-Struktur der XML-Signatur kodiert. Es enthält eine `dsig:Reference`, welche sich auf die Zeichenkette `Diese Daten sind signiert.` bezieht.

        <VerifySignatureLocation>//dsig:Signature</VerifySignatureLocation>
      </VerifySignatureInfo>
      <TrustProfileID>Test-Signaturdienste</TrustProfileID>
    </VerifyXMLSignatureRequest>

Das Element `VerifySignatureLocation` wählt die zu prüfende Signatur innerhalb des in `VerifySignatureEnvironment` angegebenen XML-Dokuments aus. Das Element `TrustProfileID` wählt das Vertrauensprofil aus, gegen das die Zertifikatsprüfung durchgeführt werden soll.

##### Response

`VerifyXMLSignatureRequest.XMLDSigManifest.resp.xml` ist eine typische Response des SP Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyXMLSignatureResponse
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <SignerInfo>
        <dsig:X509Data>...</dsig:X509Data>
      </SignerInfo>
      <SignatureCheck>
        <Code>0</Code>
      </SignatureCheck>

Die Response enthält zunächst in `SignerInfo/dsig:X509Data` Informationen über den Signator, die aus dem in der XML-Signatur enthaltenen Signatorzertifikat entnommen sind (siehe Einfaches Beispiel). Das Element`SignatureCheck` enthält das Resultat der kryptographischen Prüfung der Signatur (siehe Einfaches Beispiel).

      <XMLDSIGManifestCheck>
        <Code>0</Code>
        <Info>
          <ReferringSigReference>1</ReferringSigReference>
        </Info>
      </XMLDSIGManifestCheck>

Neu ist in dieser Response das an `SignatureCheck` anschließende Element `XMLDSIGManifestCheck`. Ein oder mehrere solche Elemente werden immer dann zurückgeliefert, wenn in `dsig:SignedInfo` der XML-Signatur `dsig:Reference` Elemente existieren, die sich auf ein Manifest nach XMLDSIG beziehen (siehe oben). Je solcher `dsig:Reference` enthält die Antwort ein korrespondierendes Element `XMLDSIGManifestCheck`, im konkreten Beispiel als eines.

Das Element `Code` gibt das Ergebnis der durchgeführten Prüfung des XMLDSIG-Manifests an. In diesem Fall bedeutet `0`, dass die Prüfung jeder `dsig:Reference` im `dsig:Manifest` (im konkreten Beispiel also genau einer `dsig:Reference`) erfolgreich durchgeführt werden konnte. Für eine Übersicht der möglichen Kodes siehe Security-Layer Spezifikation.

Das Element `Info/ReferringSigReference` enthält als Textinhalt die Nummer jenes `dsig:Reference` Elements in `dsig:SignedInfo` der XML-Signatur, welches auf das untersuchte Manifest nach XMLDSIG verweist, wobei mit `1` zu zählen begonnen wird.

      <CertificateCheck>
        <Code>0</Code>
      </CertificateCheck>
    </VerifyXMLSignatureResponse>

Das Element`CertificateCheck` enthält das Resultat der Zertifikatsprüfung (siehe Einfaches Beispiel).

#### 2.1.4.4 Ergänzungsobjekte

Dieses Beispiel zur Prüfung einer XML-Signatur (`VerifyXMLSignatureRequest.Supplements.xml`) demonstriert die Verwendung von Ergänzungsobjekten. Ein Ergänzungsobjekt betrifft entweder ein signiertes Datum (Zusammenhang mit einem `dsig:Reference` der XML-Signatur) oder jenes Dokument, in dem sich die zu prüfende XML-Signatur befindet (Zusammenhang mit `VerifySignatureEnvironment`). Es muss dann angegeben werden, wenn auf ein signiertes Datum bzw. in einem signierten Datum bzw. in dem die XML-Signatur enthaltenden XML-Dokument auf weitere Daten per Referenz verwiesen wird, diese Referenz aber von MOA SP nicht aufgelöst werden kann. Das Ergänzungsobjekt enthält dann genau diese Daten die nicht von MOA SS aufgelöst werden können.

Bitte beachten Sie, dass der dargestellte Request zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyXMLSignatureRequest xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#">
      <VerifySignatureInfo>
        <VerifySignatureEnvironment>
          <XMLContent>
            <doc:XMLDocument ... xsi:schemaLocation="urn:document urn:XMLDocument.xsd">
              <doc:Paragraph>Ich bin der erste Absatz in diesem Dokument.</doc:Paragraph>
              <doc:Paragraph ParaId="Para2">Und ich bin der zweite Absatz in diesem Dokument.
    Ich habe weiters ein eigenens ID-Attribut bekommen.</doc:Paragraph>
              <dsig:Signature Id="signature-1-1" xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
                <dsig:SignedInfo>
                  ...
                  <dsig:Reference Id="reference-1-1" URI="#Para2">
                    <dsig:Transforms>
                      <dsig:Transform Algorithm="http://www.w3.org/TR/1999/REC-xslt-19991116">
                        <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
                          <xsl:include href="XMLDocument.Para.xsl"/>
                        </xsl:stylesheet>
                      </dsig:Transform>
                      <dsig:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
                    </dsig:Transforms>
                    ...
                  </dsig:Reference>
                </dsig:SignedInfo>
                <dsig:SignatureValue>5rXIIkbP/djWmTgQEICy...0Sf8jvnz+d</dsig:SignatureValue>
                <dsig:KeyInfo>...</dsig:KeyInfo>
              </dsig:Signature>
            </doc:XMLDocument>
          </XMLContent>
        </VerifySignatureEnvironment>

Das Element `VerifySignatureEnvironment` enthält das XML-Dokument mit der zu prüfenden XML-Signatur.

Man erkennt, dass das Attribut `dsig:Reference/@URI` das Element`doc:Paragraph` mit dem auf den Wert `Para2` gesetzten ID-Attribut `ParaId` referenziert. MOA kann jedoch den Umstand, dass es sich bei `doc:Paragraph/@ParaId` um ein ID-Attribut handelt, nur dann erkennen, wenn es das XML-Dokument validierend parst. Der dazu nötige Verweis auf das passende XML-Schema ist zwar mit dem Attribut `xsi:schemaLocation` vorhanden, jedoch handelt es sich dabei mit `urn:XMLDocument.xsd` um eine nicht auflösbare Referenz. Deshalb wird im Request ein passendes Ergänzungsobjekt benötigt (siehe unten).

Weiters erkennt man, dass `dsig:Reference` ein XSLT-Transformation enthält. Im darin kodierten Stylesheet-Parameter (`dsig:Transform/xsl:stylesheet`) wird ein weiterer Stylesheet inkludiert (`XMLDocument.Para.xsl`). Diese Referenz ist aber wiederum für MOA SP nicht auflösbar. Auch hier wird also ein passendes Ergänzungsobjekt benötigt (siehe unten).

        <VerifySignatureLocation xmlns:doc="urn:document"
          xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">/doc:XMLDocument/dsig:Signature</VerifySignatureLocation>
      </VerifySignatureInfo>

Das Element `VerifySignatureLocation` wählt die zu prüfende Signatur innerhalb des in `VerifySignatureEnvironment` angegebenen XML-Dokuments aus.

      <SupplementProfile>
        <Content Reference="XMLDocument.Para.xsl">
          <LocRefContent>http://localhost:8080/referencedData/XMLDocument.Para.xsl</LocRefContent>
        </Content>
      </SupplementProfile>

Das erste Element `SupplementProfile` enthält nun das Ergänzungsobjekt für den oben beschriebenen inkludierten Stylesheet. `Content/@Reference` enthält die Referenz genau so, wie sie oben im Attribut `xsl:stylesheet/@href` angegeben wurde. Im Inhalt von `Content` werden entweder explizit jene Daten angegeben, die von MOA statt des Auflösens der Referenz verwendet werden sollen (`Base64Content` oder`XMLContent`), oder aber es wird - wie im konkreten Beispiel - ``mit `LocRefContent` eine auflösbare Referenz für diese Daten an MOA SP übergeben.

      <SupplementProfile>
        <Content Reference="urn:XMLDocument.xsd">
          <XMLContent>
            <xs:schema targetNamespace="urn:document" xmlns:xs="http://www.w3.org/2001/XMLSchema"
              xmlns="urn:document" elementFormDefault="qualified" attributeFormDefault="unqualified">
              ...
            </xs:schema>
          </XMLContent>
        </Content>
      </SupplementProfile>
      <TrustProfileID>Test-Signaturdienste</TrustProfileID>
    </VerifyXMLSignatureRequest>

Das zweite Element `SupplementProfile` enthält analog das Ergänzungsobjekt für das oben beschriebene XML-Schema. `Content/@Reference` enthält die Referenz genau so, wie sie oben im Attribut `xsi:schemaLocation` angegeben wurde.

##### Response

`VerifyXMLSignatureRequest.Supplements.resp.xml` ist eine typische Response des SP Webservices auf den obigen Request. Er wird an dieser Stelle nicht näher analysiert, da er keine für das Thema des Beispiels relevanten Besonderheiten aufweist.

#### 2.1.4.5 Signatur-Manifest des Security-Layers

##### Request

Dieses Beispiel zur Prüfung einer XML-Signatur (`VerifyXMLSignatureRequest.SigManifest.xml`) demonstriert die Überprüfung des Zusammenhangs zwischen den Referenz-Eingangsdaten und den Hash-Eingangsdaten für die `dsig:Reference`-Elemente einer XML-Signatur. Mit Hilfe dieser Prüfung kann eine Anwendung feststellen, ob bei der Erstellung einer XML-Signatur jene Transformationen bzw. auch jene inkludierten Stylesheets (vgl. Implizite Transformationsparameter) einer XSLT-Transformation angewendet wurden, welche die Anwendung vorgegeben hat. Bei erfolgreicher Prüfung dieses Zusammenhangs kann die Anwendung die Referenz-Eingangsdaten einer `dsig:Reference` als gesichert ansehen, obwohl eigentlich die Hash-Eingangsdaten durch die Signatur gesichert sind. Dies ist jenen Fällen sinnvoll, in denen die Anwendung grundsätzlich mit XML-Daten arbeitet, diese Daten jedoch für das Signieren durch eine Person in ein für diese Person verständliches Format wie z.B. HTML umgewandelt werden sollen.

    <VerifyXMLSignatureRequest
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <VerifySignatureInfo>
        <VerifySignatureEnvironment>
          <XMLContent>
            <doc:XMLDocument xmlns:doc="urn:document" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="urn:document http://localhost:8080/referencedData/XMLDocument.xsd">
              <doc:Paragraph>Ich bin der erste Absatz in diesem Dokument.</doc:Paragraph>
              <doc:Paragraph ParaId="Para2">Und ich bin der zweite Absatz in diesem Dokument.
    Ich habe weiters ein eigenens ID-Attribut bekommen.</doc:Paragraph>
              <dsig:Signature xmlns:dsig="http://www.w3.org/2000/09/xmldsig#" Id="signature-1-1">
                <dsig:SignedInfo>
                  ...
                  <dsig:Reference Id="reference-1-1" URI="#Para2">
                    <dsig:Transforms>
                      <dsig:Transform Algorithm="http://www.w3.org/TR/1999/REC-xslt-19991116">
                        <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
                          <xsl:include href="http://localhost:8080/referencedData/XMLDocument.Para.xsl"/>
                        </xsl:stylesheet>
                      </dsig:Transform>
                      <dsig:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
                    </dsig:Transforms>
                    ...
                  </dsig:Reference>
                  <dsig:Reference
                    Type="http://www.buergerkarte.at/specifications/Security-Layer/20020225#SignatureManifest"
                    URI="#manifest-1-1">
                    ...
                  </dsig:Reference>
                  <dsig:Reference Type="http://uri.etsi.org/01903/v1.1.1#SignedProperties" ...>...</dsig:Reference>
                </dsig:SignedInfo>
                <dsig:SignatureValue>jnXc/X+hUY...uBxo9q</dsig:SignatureValue>
                <dsig:KeyInfo>...</dsig:KeyInfo>
                <dsig:Object>
                  <dsig:Manifest Id="manifest-1-1">
                    <dsig:Reference URI="http://localhost:8080/referencedData/XMLDocument.Para.xsl">
                      ...
                    </dsig:Reference>
                  </dsig:Manifest>
                </dsig:Object>
                <dsig:Object Id="etsi-signed-1-1">
                  <etsi:QualifyingProperties Target="#signature-1-1" xmlns:etsi="http://uri.etsi.org/01903/v1.1.1#">
                  ...
                  </etsi:QualifyingProperties>
                </dsig:Object>
              </dsig:Signature>
            </doc:XMLDocument>
          </XMLContent>
        </VerifySignatureEnvironment>

Das Element `VerifySignatureEnvironment` enthält das XML-Dokument mit der zu prüfenden XML-Signatur. Die XML-Signatur wurde von einer Bürgerkarten-Umgebung erstellt. Man erkennt, dass das Element `dsig:SignedInfo` der XML-Signatur drei `dsig:Reference`-Elemente enthält.

Die erste `dsig:Reference` bezieht sich auf die eigentlich signierten Nutzdaten. Das zweite `doc:Paragraph`-Element stellt die Referenz-Eingangsdaten für diese `dsig:Reference` dar, welche mit Hilfe einer XSLT-Transformation in ein kleines HTML-Dokument übergeführt wird, worüber dann der Hashwert der dsig:Reference gebildet wird (Hash-Eingangsdaten).

Die zweite `dsig:Reference` bezieht sich auf das von der Bürgerkarten-Umgebung angefertigte Signaturmanifest. Das Signaturmanifest ist vorhanden, weil die XSLT-Transformation der ersten `dsig:Reference` einen weiteren Stylesheet inkludiert, und die Daten dieses weiteren Stylesheets ansonsten nicht von der XML-Signatur abgedeckt wären (vgl. Implizite Transformationsparameter). Das Signaturmanifest enthält eine einzige `dsig:Reference`, die den inkludierten Stylesheet referenziert und so in die XML-Signatur einbindet.

Die dritte `dsig:Reference` bezieht sich auf die von der Bürgerkarten-Umgebung angefertigten Signatureigenschaften, die hier nicht näher betrachtet werden.

        <VerifySignatureLocation xmlns:doc="urn:document">/doc:XMLDocument/dsig:Signature</VerifySignatureLocation>
      </VerifySignatureInfo>

Das Element `VerifySignatureLocation` wählt die zu prüfende Signatur innerhalb des in `VerifySignatureEnvironment` angegebenen XML-Dokuments aus.

      <SignatureManifestCheckParams ReturnReferenceInputData="true">
        <ReferenceInfo>
          <VerifyTransformsInfoProfile>
            <dsig:Transforms>
              <dsig:Transform Algorithm="http://www.w3.org/TR/1999/REC-xslt-19991116">
                <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
                  <xsl:include href="http://localhost:8080/referencedData/XMLDocument.Para.xsl"/>
                </xsl:stylesheet>
              </dsig:Transform>
              <dsig:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
            </dsig:Transforms>
            <TransformParameter URI="http://localhost:8080/referencedData/XMLDocument.Para.xsl"/>
          </VerifyTransformsInfoProfile>
          <VerifyTransformsInfoProfile>
            <dsig:Transforms>
              <dsig:Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
            </dsig:Transforms>
          </VerifyTransformsInfoProfile>
        </ReferenceInfo>
      </SignatureManifestCheckParams>
      <TrustProfileID>Test-Signaturdienste</TrustProfileID>
    </VerifyXMLSignatureRequest>

Mit Angabe des optionalen Elements `SignatureManifestCheckParams` wird MOA SP angewiesen, den oben skizzierten Zusammenhang zwischen Referenz-Eingangsdaten und Hash-Eingangsdaten zu überprüfen. Wird das Attribut `ReturnReferenceInputData` wie im Beispiel auf den Wert `true` gesetzt, liefert MOA SP in der Response die Hash-Eingangsdaten für alle Referenzen in `dsig:SignedInfo` der XML-Signatur an die Anwendung zurück, was in der Regel von der Anwendung wohl gewünscht wird, wenn MOA SP schon den Zusammenhang zwischen Referenz-Eingangsdaten und Hash-Eingangsdaten prüfen soll.

Die Prüfung des Zusammenhangs untergliedert sich in zwei Teilprüfungen:

- Überprüfung, ob jede `dsig:Reference` in `dsig:SignedInfo` der Signatur eine vorgegebene Transformationskette inkludiert;
- Überprüfung, ob die in der vorgegebenen Transformationskette ggf. enthaltenen inkludierten Stylesheets (implizite Transformationsparameter) durch ein Signaturmanifest mitsigniert sind.

Damit MOA SP die erste Teilprüfung durchführen kann, muss in `SignatureManifestCheckParams` je `dsig:Reference` Element in `dsig:SignedInfo` der XML-Signatur ein Element `ReferenceInfo` angeben. Ausgenommen sind `dsig:Reference`-Elemente, die auf ein Signaturmanifest (Attribut `Type` ist gesetzt und hat den Wert `http://www.buergerkarte.at/specifications/Security-Layer/20020225#SignatureManifest`), auf ein XMLDSIG-Manifest (Attribut `Type` ist gesetzt und hat den Wert `http://www.w3.org/2000/09/xmldsig#Manifest`) oder auf Signatureigenschaften (Attribut `Type` ist gesetzt und hat den Wert `http://uri.etsi.org/01903/v1.1.1#SignedProperties`) verweisen.

Das Element `ReferenceInfo` enthält eine oder mehrere erlaubte Transformationsketten, die jeweils durch ein Element `VerifyTransformsInfoProfile/dsig:Transforms` repräsentiert werden. Im konkreten Beispiel werden für die einzige zu prüfende `dsig:Reference` zwei erlaubte Transformationsketten angegeben. Die Transformationen in der `dsig:Reference` müssen einer dieser beiden Ketten entsprechen; im konkreten Beispiel entsprechen sie der ersten.

Nachdem die erste erlaubte Transformationskette eine XSLT-Transformation mit einem inkludierten Stylesheet enthält, muss MOA SP auch überprüfen, ob dieser inkludierte Stylesheet korrekt durch ein Signaturmanifest mitunterschrieben wurde. Nachdem wichtig ist, dass nicht irgendein beliebiger Stylesheet verwendet und mitunterschrieben wurde, sondern genau jener, den die Anwendung bei der Signaturerstellung vorgegeben hat, muss die Anwendung MOA SP mitteilen, welcher Stylesheet das sein muss. Die Anwendung verwendet dazu das Element `VerifyTransformsInfoProfile/TransformParameter`. Das Attribut `TransformParameter/@URI` enthält die Referenz auf den Stylesheet genau so, wie er im Stylesheet-Parameter der zu prüfenden Signatur verwendet wird (`dsig:Transform/xsl:stylesheet/xsl:inlcude/@href`). Für den Inhalt dieses Elements hat die Anwendung drei Möglichkeiten:

- Die Anwendung lässt den Inhalt leer. Dies wird sie dann machen, wenn sie darauf vertrauen kann, dass die Auflösung der in `TransformParameter/@URI` angegebenen Referenz bei der Signaturprüfung zum gleichen Resultat führt wie seinerzeit beim Erstellen der Signatur (z.B. weil die Referenz auf einen Webserver unter Kontrolle der Anwendung zeigt);
- Die Anwendung gibt im Element `TransformParameter/Base64Content` explizit den inkludierten Stylesheet an. MOA SP verwendet dann diesen Stylesheet, um den Hashwert der `dsig:Reference` im Signaturmanifest zu kontrollieren;
- Die Anwendung gibt im Element `TransformParameter/Hash` den Hashwert des inkludierten Stylesheets an. MOA SP löst dann die Referenz in `dsig:Transform/xsl:stylesheet/xsl:inlcude/@href` auf und stellt sicher, dass der über das Auflösungsergebnis gebildete Hashwert jenem in `TransformParameter/Hash` entspricht. Diese Möglichkeit wird die Anwendung dann verwenden, wenn es sich um einen sehr umfangreichen Stylesheet handelt, der nicht im Request mitübertragen werden soll.

##### Response

`VerifyXMLSignatureRequest.SigManifest.resp.xml` ist eine typische Response des SP Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyXMLSignatureResponse
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <SignerInfo>...</SignerInfo>

Die Response enthält zunächst in `SignerInfo/dsig:X509Data` Informationen über den Signator, die aus dem in der XML-Signatur enthaltenen Signatorzertifikat entnommen sind (siehe Einfaches Beispiel).

      <ReferenceInputData PartOf="SignedInfo">
        <XMLContent xml:space="preserve">
          <doc:Paragraph ParaId="Para2" xmlns:doc="urn:document"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">...</doc:Paragraph>
        </XMLContent>
      </ReferenceInputData>
      <ReferenceInputData PartOf="SignedInfo">
        <XMLContent xml:space="preserve">
          <dsig:Manifest Id="manifest-1-1" xmlns:doc="urn:document" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
            ...
          </dsig:Manifest>
        </XMLContent>
      </ReferenceInputData>
      <ReferenceInputData PartOf="SignedInfo">
        <XMLContent xml:space="preserve">
          <etsi:SignedProperties xmlns:doc="urn:document"
            xmlns:etsi="http://uri.etsi.org/01903/v1.1.1#" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
            ...
          </etsi:SignedProperties>
        </XMLContent>
      </ReferenceInputData>

Nachdem im Request spezifiziert wurde, dass in der Response die Referenzeingangsdaten für alle `dsig:Reference`-Elemente von `dsig:SignedInfo` (bzw. auch für jede `dsig:Reference` aus einem `dsig:Manifest`, auf das mittels des Attributs `Type="http://www.w3.org/2000/09/xmldsig#Manifest"` in einer `dsig:Reference` aus `dsig:SignedInfo` verwiesen wird; solche Manifeste kommen aber in diesem Beispiel nicht vor) der geprüften XML-Signatur übermittelt werden sollen, enthält die Response nach `SignerInfo` drei `ReferenceInputData`-Elemente. Das erste `ReferenceInputData`-Element enthält das zuvor besprochene `doc:Paragraph` Element, das zweite das Signaturmanifest, das dritte die Signatureigenschaften. Das Attribut `PartOf` jedes Elements weist mit dem Wert `SignedInfo` darauf hin, dass die `dsig:Reference`, für welche die Referenzeingangsdaten gelten, Teil von `dsig:SignedInfo` ist.

      <SignatureCheck>
        <Code>0</Code>
      </SignatureCheck>

Das Element`SignatureCheck` enthält das Resultat der kryptographischen Prüfung der Signatur (siehe Einfaches Beispiel).

      <SignatureManifestCheck>
        <Code>0</Code>
      </SignatureManifestCheck>

Das Element `SignatureManifestCheck` enhält das Resultat der Prüfung des Zusammenhangs zwischen Referenz-Eingangsdaten und Hash-Eingangsdaten. Der Kode `0` im konkreten Beispiel bedeutet, dass alle Referenzen die in der Anfrage zur Überprüfung der XML-Signatur gemachten Einschränkungen bezüglich der erlaubten Transformationskette(n) einhalten, sowie dass die Anforderungen hinsichtlich des Signaturmanifests werden eingehalten. Für eine Übersicht der möglichen Kodes siehe die Spezifikation zu MOA SP/SS, Abschnitt 5.1.3.1.4.

      <CertificateCheck>
        <Code>0</Code>
      </CertificateCheck>
    </VerifyXMLSignatureResponse>

Das Element`CertificateCheck` enthält das Resultat der Zertifikatsprüfung (siehe Einfaches Beispiel).

#### 2.1.4.6 Prüfung gegen Trustprofil mit TSL Unterstützung

##### Request

`VerifyXMLSignatureRequest.TSL.xml` ist ein einfacher XML-Request zur Prüfung einer XML-Signatur. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass der dargestellte Request zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyXMLSignatureRequest xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#">
      <VerifySignatureInfo>
        <VerifySignatureEnvironment>
          <XMLContent>
            <dsig:Signature Id="signature-1-1" xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
              [..]
            </dsig:Signature>
          </XMLContent>
        </VerifySignatureEnvironment>

Das Element `VerifySignatureEnvironment` enthält jenes XML-Dokument, das die zu prüfende XML-Signatur enthält.

        <VerifySignatureLocation
          xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">//dsig:Signature</VerifySignatureLocation>
      </VerifySignatureInfo>

Das Element `VerifySignatureLocation` enthält als Text den XPath-Ausdruck zur Selektion der XML-Signatur innerhalb des zu prüfenden XML-Dokuments. Die Auswertung des XPath-Ausdrucks muss genau ein Element `dsig:Signature` ergeben. Bitte beachten Sie, dass im Kontext des Elements `VerifySignatureLocation` alle im XPath-Ausdruck verwendeten Namespace-Präfixe bekannt sein müssen (hier das Präfix `dsig`).

      <TrustProfileID>Test-TSLProfil</TrustProfileID>
    </VerifyXMLSignatureRequest>

Das Element `TrustProfileID` schließlich enthält den Bezeichner des Vertrauensprofils, gegen das die Zertifikatsprüfung von MOA SP durchgeführt wird. In diesem Falle muss für das Vertrauenprofil die TSL Unterstützung aktiviert sein. In der beispielhaften Konfiguration sp.minimum_with_tsl.config.xml ist so eine Vertrauensprofile mit der ID Test-TSLProfil eingerichtet.

##### Response

`VerifyXMLSignatureRequest.TSL.resp.xml` ist eine typische Response des SP Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyXMLSignatureResponse
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
      <SignerInfo>
        <dsig:X509Data>
          <dsig:X509SubjectName>T=DI,serialNumber=847206943023,givenName=Klaus,SN=Stranacher,
      CN=Klaus Stranacher,C=AT</dsig:X509SubjectName>
          <dsig:X509IssuerSerial>
            <dsig:X509IssuerName>CN=a-sign-premium-mobile-03,OU=a-sign-premium-mobile-03,
      O=A-Trust Ges. f. Sicherheitssysteme im elektr. Datenverkehr GmbH,C=AT</dsig:X509IssuerName>
            <dsig:X509SerialNumber>685117</dsig:X509SerialNumber>
          </dsig:X509IssuerSerial>
          <dsig:X509Certificate>...</dsig:X509Certificate>
            <QualifiedCertificate/>
            <SecureSignatureCreationDevice Source="Certificate"/>
            <IssuerCountryCode>AT</IssuerCountryCode>
        </dsig:X509Data>
      </SignerInfo>

Die Response enthält zunächst in `SignerInfo/dsig:X509Data` Informationen über den Signator, die aus dem in der XML-Signatur enthaltenen Signatorzertifikat entnommen sind.

`dsig:X509SubjectName` ist immer vorhanden und enthält den Namen des Signators. `dsig:X509IssuerSerial` ist ebenfalls immer vorhanden und enthält den Namen des Austellers des Signatorzertifikats (`dsig:X509IssuerName`) sowie die Seriennummer des Zertifikats (`dsig:X509SerialNumber`). Auch `dsig:X509Certificate` ist ist immer vorhanden und enthält das Signatorzertifikat in base64 kodierter Form.

Optional vorhanden ist das inhaltslose Element `QualifiedCertificate`, und zwar dann, wenn es sich beim Signatorzertifikat um ein qualifiziertes Zertifikat handelt. Optional vorhanden ist das Element `SecureSignatureCreationDevice`, und zwar dann wenn die Signatur mittels einer sicheren Signaturerstellungseinheit erzeugt wurde. Das Attribut `Source`, gibt dabei an ob diese Information über die entsprechende TSL (`Source=TSL`) oder über das Zertifikat ermittelt wurde (`Source=Certificate`). Das weitere optionale Element `IssuerCountryCode` gibt dabei den Ländercode des Zertifizierungsdiensteanbieters an, der das Signaturzertifikat ausgestellt hat. Ebenfalls optional vorhanden (nicht in diesem Beispiel) ist schließlich das Element `PublicAuthority`, und zwar dann, wenn das Signatorzertifikat die österreichspezifische Zertifikatserweiterung Verwaltungseigenschaft aufweist. Ist in dieser Zertifikatserweiterung das Verwaltungskennzeichen mitkodiert, wird dieses Kennzeichen als Textinhalt des optionalen Elements `PublicAuthority/Code` geliefert.

      <SignatureCheck>
        <Code>0</Code>
      </SignatureCheck>

Anschließend an `SignerInfo` enthält die Response mit `SignatureCheck/Code` das Resultat der kryptographischen Prüfung der Signatur. In unserem Beispiel ist dort der Wert `0` enthalten, d. h. die Signatur konnte erfolgreich validiert werden. Für eine Übersicht der möglichen Kodes siehe Security-Layer Spezifikation.

      <CertificateCheck>
        <Code>0</Code>
      </CertificateCheck>

Abschließend enthält die Response mit `CertificateCheck/Code` das Resultat der Prüfung des Signatorzertifikats. Zunächst prüft MOA SP, ob ausgehend vom Signatorzertifikat eine Zertifikatskette zu einem im zugehörigen Vertrauensprofil konfigurierten sog. Trust Anchor gebildet werden kann. Gelingt dies, wird die Gültigkeit jedes Zertifikats dieser Kette überprüft. In unserem Beispiel enthält `Code` den Wert `0`, d. h. MOA SP konnte die Kette bilden, und alle Zertifikate der Kette sind gültig. Für eine Übersicht der möglichen Kodes siehe Security-Layer Spezifikation.

### 2.1.5 Prüfung einer PAdES-Signatur

#### Request

Dieses Beispiel ist ein einfacher Request zur Prüfung einer PAdES-Signatur. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass der nachfolgende Ausschnitt aus dem Request aus Gründen der Übersichtlichkeit gekürzt wurde.

    <VerifyPDFSignatureRequest
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#">
    	<DateTime>2004-08-18T17:00:00+02:00</DateTime>
    	<ExtendedValidation>true</ExtendedValidation>
      <PDFSignature>MIIHsAYJKo...4sLL6kpOPJaLg==</PDFSignature>
      <TrustProfileID>Test-Signaturdienste</TrustProfileID>
    </VerifyPDFSignatureRequest>

Mit dem optionalen Element `DateTime` kann der Zeitpunkt der Signaturprüfung explizit vorgegeben werden. Inhalt dieses Elements ist die Angabe von Datum und Uhrzeit entsprechend dem XML-Schema Datentyp dateTime. Enthält der angegebene Zeitpunkt keinen Zeitzonen-Offset zur UTC, wird der Zeitpunkt als lokale Zeit des Servers interpretiert, auf dem MOA SP läuft. Wird `DateTime` nicht angegeben, versucht MOA SP, den Zeitpunkt der Signaturerstellung aus der Signatur zu ermitteln (anhand des Signaturattributs SigningTime). Enthält die Signatur keinen Zeitpunkt der Signaturerstellung, verwendet MOA SP die aktuelle Systemzeit des Servers, auf dem es läuft. Das optionale Element `ExtendedValidation` kann dafür genutzt werden den Formvalidierungsmodus für PAdES Signaturen zu aktivieren. Diesem Fall enthält die Response spezifische Informationen bezüglich des PAdES Profils der Signatur und erweiterte Zertifikatsprüfungsergebnisse. Detailinformationen zu den erweiterten Ergebnissen finden Sie im Abschnitt 2.1.4.2, da diese für alle unterstützen Signaturformate identisch sind.

Der Request enthält im Element `PDFSignature` die zu prüfende PAdES-Signatur, und zwar in base64 kodierter Form.

Abschließend enthält der Request in `TrustProfileID` die Angabe des Vertrauensprofils, gegen das die Vertrauensprüfung des Zertifikats durchgeführt werden soll. Ein Vertrauensprofil mit dem angegebenen Namen muss in der für die Signaturprüfung verwendeten Instanz von MOA SP eingerichtet sein.

##### Response

Nachstehend ist eine typische Response des SP Webservices auf den obigen Request. Sein Aufbau wird nachfolgend analysiert. Bitte beachten Sie, dass die dargestellte Response zur bessernen Lesbarkeit eingerückt und gekürzt wurde.

    <VerifyPDFSignatureResponse
      xmlns="http://reference.e-government.gv.at/namespace/moa/20020822#"
      xmlns:dsig="http://www.w3.org/2000/09/xmldsig#">
    	<SignatureResult>
    	  <SignerInfo>
      	  <dsig:X509Data>
      	    <dsig:X509SubjectName>serialNumber=615536615920,givenName=Gregor,SN=Karlinger,
    CN=Gregor Karlinger,C=AT</dsig:X509SubjectName>
    	      <dsig:X509IssuerSerial>
    	        <dsig:X509IssuerName>CN=TrustSignTest-Sig-01,OU=TrustSignTest-Sig-01,
    O=A-Trust Ges. für Sicherheitssysteme im elektr. Datenverkehr GmbH,C=AT</dsig:X509IssuerName>
    	        <dsig:X509SerialNumber>2892</dsig:X509SerialNumber>
    	      </dsig:X509IssuerSerial>
    	      <dsig:X509Certificate>...</dsig:X509Certificate>
    	      <QualifiedCertificate/>
    	    </dsig:X509Data>
    	  </SignerInfo>
    	  <SigningTime>2017-01-27T13:56:26Z</SigningTime>
        <SignatureAlgorithm>SHA256withECDSA</SignatureAlgorithm>
        <SignatureCheck>
        	<Code>0</Code>
        </SignatureCheck>
        <CertificateCheck>
    		...
    	  <SignatureProperties>
          <SignatureCoversFullPDF>true</SignatureCoversFullPDF>
          <SignatureByteRange>0,83991,92185,19061</SignatureByteRange>
        </SignatureProperties>
    	</SignatureResult>
    	<SignatureResult>
    		...

Die Response beinhaltet als erstes kein, ein oder mehrere `SignatureResult` Elemente, welche als Kindelemende die Prüfergebnisse der einzelnen im PDF Dokument gefundenen Signaturen beinhalten. Die Kindelement sind weitgehend identisch zur Response bei CMS Signaturen aufgebau. Somit sei hier auf das Kapitel 2.1.3.2 verwiesen. Zusätzlich zu den in Kapitel 2.1.3.2 beschriebenen Elementen, beinhaltet das `SignatureResult` im Falle einer `VerifyPDFSignatureResponse` weitere Eigenschaften zur geprüften Signatur. Diese werden im Element `SignatureProperties` dargestellt und beinhalten die folgenden beiden Kind-Elemente. Das Element `SignatureCoversFullPDF` mit den möglichen Werten `true/false` zeigt an ob die PAdES Signatur das Dokument vollständig umfasst. Das Element `SignatureByteRange` definiert technisch die Bereiche des Dokuments welche in die Signaturbereichnung eingeflossen sind. Das Format des Elementwerts ist identisch zur PDF 1.7 Spezifikation (siehe Table 8.102 Entries in a signature dictionary) und besteht aus Integer-Paaren mit Byte-Offset und der Länge in Byte. (z.B. zwei Blöcke: Paar 1: Offset 0 Byte, Länge 83991 Byte und Paar 2: Offset 92185 Byte, Länge 19061 Byte)

## 2.2 Webservice-Clients

Abschnitt 2.1 bespricht eine Reihe von typischen XML-Requests, die über die Webservice-Schnittstelle an MOA SP/SS gesendet werden können, um entweder Signaturen zu erstellen (MOA SS) oder Signaturen zu prüfen (MOA SP). Dieser Abschnitt zeigt die Verwendung des prototypischen Webservice-Clients, der mit dieser Dokumentation zu MOA SP/SS ausgeliefert wird.

### 2.2.1 Übersicht

Der Webservice-Client existiert in drei Varianten, wobei jede Variante in einer eigenen Java-Klasse implementiert ist:

- Der einfache Client (`HTTP.java`) arbeitet ohne Authentifikation. Er prüft weder die Authentizität des verwendeten MOA-Webservices, noch identifiziert er sich selbst gegenüber dem MOA-Webservice.
- Der Client mit Server-Authentisierung (`HTTPSServerAuth.java`) prüft die Authentizität des verwendeten MOA-Websservices an Hand dessen SSL-Serverzertifikats, identifiziert sich selbst jedoch nicht gegenüber dem MOA-Webservice.
- Der Client mit Client- und Server-Authentisierung (`HTTPSClientAuth.java`) prüft einerseits die Authentizität des verwendeten MOA-Websservices an Hand dessen SSL-Serverzertifikats; andererseits weist er sich selbst mittels eines SSL-Client-Zertifikats gegenüber dem MOA-Webservice aus.

Welcher der drei Varianten des Webservice-Clients zum Einsatz kommen soll, hängt von der Art ab, wie das MOA-Webservice betrieben wird, d.h. ob es Server- bzw. Client-Authentisierung unterstützt bzw. verlangt. Befinden sich sowohl MOA-Webservice als auch der Webservice-Client im gleichen, abgeschotteten Netzwerk, kann auch eine Kommunikation ohne Authenifikation in Betracht gezogen werden. Ansonsten wird der Standardfall wohl der Betrieb mit Server-Authentisierung (Verwendung von MOA SP) bzw. mit Server- und Client-Authentisierung (Verwendung von MOA SS) sein.

Hinweis: Das Wurzelverzeichnis dieses Handbuchs stellt ein komplettes und sofort verwendbares Eclipse Projekt dar.

### 2.2.2 Gemeinsamkeiten

Dieser Abschnitt beschreibt die Gemeinsamkeiten aller drei Varianten des Webservice-Clients.

Zunächst einmal benötigen alle drei Varianten die folgenden Java-Bibliotheken, die im Ordner clients/webservice/lib/ dieses Handbuchs bereits enthalten sind:

Java-Bibliothek | Bemerkung
--- | ---
Java SE | Java Standard Edition (Software Development Kit bzw. Java Runtime Environment)
Apache Xerces | XML-Parser, Version 2.0.2 oder höher
AXIS Framework | Webservice-Framework, ab Version 1.1.

Weiters ist allen drei Varianten der folgende Kern-Ablauf gemeinsam:

1. Der Webservice-Client liest einen vorbereiteten MOA-XML-Request (z. B. einen der in Abschnitt 2.1 gezeigten) vom Dateisystem ein.
2. Der Webservice-Client erstellt einen SOAP-Request mit dem vom Dateisystem gelesenen MOA-XML-Request als Nutzlast.
3. Der Webservice-Client sendet den erstellten SOAP-Request über HTTP an MOA SP/SS.
4. Der Webservice-Client empfängt die SOAP-Response von MOA SP/SS.
5. Der Webservice-Client extrahiert die Nutzlast des SOAP-Responses (d. h. die zum MOA-XML-Request aus Schritt 1 passende MOA-XML-Response), gibt diese auf die Konsole aus und speichert sie im Dateisystem.

Konfiguriert werden können alle drei Varianten mit Hilfe von zwei Kommandozeilen-Parametern:

1. Der erste Kommandozeilenparameter gibt an, ob MOA SS (Wert `sign`) oder MOA SP (Wert `verify`) kontaktiert werden soll.
2. Der zweite Kommandozeilenparameter enthält Pfad und Dateiname einer Java-Properties-Datei, die die weiteren Konfigurationsparameter für den Webservice-Client enthält. Ein relativer Pfad wird als relativ zum Arbeitsverzeichnis der Java Virtual Machine interpretiert. Genaue Infos zu den möglichen Konfigurationsparametern entnehmen Sie bitte der Quellcodedokumentation der jeweiligen Variante des Webservice-Clients. `http.properties` enthält eine auf dieses Handbuch abgestimmte Konfiguration.

### 2.2.3 Besonderheiten von `HTTPSServerAuth.java`

Diese Variante des Webservice-Clients baut im Schritt 3 des Kernablaufs aus Abschnitt 2.2.2 eine SSL-Verbindung mit Server-Authentifizierung zum MOA SP/SS Server auf. In dieser SSL-Verbindung sendet der Webservice-Client dann den erstellten SOAP-Request über HTTPS.

Die entsprechende Konfiguration (Speicher für die vertrauenswürdigen Serverzertifikate, Typ dieses Speichers, Passwort für diesen Speicher) wird mittels zusätzlicher Parameter in der in Abschnitt 2.2.2 besprochenen Java-Properties-Datei vorgenommen. Genaue Infos zu diesen Konfigurationsparametern entnehmen Sie bitte der Quellcodedokumentation von `HTTPSServerAuth.java`. `http.properties` enthält eine auf dieses Handbuch abgestimmte Konfiguration.

Falls Sie Probleme beim SSL-Verbindungsaufbau zwischen Webservice-Client und MOA SP/SS Webservice haben, empfiehlt sich die Aktivierung des SSL Loggings. Das Setzen der dafür notwendigen Java System Property ist im Quellcode von `HTTPSServerAuth.java` bereits enthalten, jedoch auskommentiert. Suchen Sie einfach nach dem String `javax.net.debug`, um zur entsprechenden Stelle im Quellcode zu gelangen.

### 2.2.4 Besonderheiten von `HTTPSClientAuth.java`

Diese Variante des Webservice-Clients baut im Schritt 3 des Kernablaufs aus Abschnitt 2.2.2 eine SSL-Verbindung mit Server- und Client-Authentifizierung zum MOA SP/SS Server auf. In dieser SSL-Verbindung sendet der Webservice-Client dann den erstellten SOAP-Request über HTTPS.

Die gegenüber Abschnitt 2.2.3 zusätzlich notwendige Konfiguration (Speicher für das SSL-Client-Zertifikat sowie den dazugehörigen privaten Schlüssel, Typ dieses Speichers, Passwort für diesen Speicher) wird mittels zusätzlicher Parameter in der in Abschnitt 2.2.2 besprochenen Java-Properties-Datei vorgenommen. Genaue Infos zu diesen Konfigurationsparametern entnehmen Sie bitte der Quellcodedokumentation von `HTTPSClientAuth.java`. `http.properties` enthält eine auf dieses Handbuch abgestimmte Konfiguration.

Beachten Sie bitte auch den Hinweis zum SSL Logging aus Abschnitt 2.2.3.

## 2.3 Zertifikat einer Schlüsselgruppe auslesen

Ab der Version 2.0.3 von MOA-SPSS kann das Zertifikat einer Schlüsselgruppe über ein Web Interface abgerufen werden. MOA-SPSS bietet hierfür folgenden Endpunkt:

    http(s)://......../moa-spss/Certificate?id=<Name der Schlüsselgruppe>

Mit dem http GET Parameter id kann die gewünsche Schlüsselgruppe ausgewählt werden.

# 3 Verwendung der Klassenbibliothek

Neben dem Betrieb von MOA SP/SS als Webservice ist als Alternative auch die Verwendung von MOA SP/SS als Klassenbibliothek möglich, also die direkte Einbindung in ein Java-Programm unter Verwendung des Application Programmers Interface (API) von MOA SP/SS.

## 3.1 Vorbereitung

Um das API von MOA SP/SS verwenden zu können, müssen einerseits die MOA-Bibliotheken selbst, andererseits eine Reihe von unterstützenden Bibliotheken in den Klassenpfad aufgenommen werden. Eine Übersicht dazu finden Sie im Installationshandbuch im Abschnitt 3.

## 3.2 Allgemeines

Der strukturelle Aufbau der API entspricht weitgehend der Struktur eines MOA-XML-Requests. Es werden daher in diesem Abschnitt nur zwei grundlegende Beispiele gebracht; für komplexere Aufgaben können die XML-Beispiele aus Abschnitt 2.1 als Vorlage verwendet und einfach in die "API-Welt" übertragen werden.

## 3.3 Beispiele

Dieses Handbuch enthält zwei Beispiele für die Verwendung der API von MOA SP/SS:

1. `CreateXMLSignature.java`: Erstellung einer einfachen XML-Signatur; dieses Beispiel entspricht dem MOA-XML-Request aus Abschnitt 2.1.1.1.
   Die Konfiguration der API erfolgt über Kommandozeilenparameter (Lage der Konfigurationsdatei für MOA SP/SS, Lage der Konfigurationsdatei für das Logging mit Log4j). Detaillierte Informationen dazu finden Sie in der Quellcodedokumentation des Beispiels.
2. `VerifyXMLSignature.java`: Prüfung einer einfachen XML-Signatur; dieses Beispiel entspricht dem MOA-XML-Request aus Abschnitt 2.1.3.1.
   Die Konfiguration der API erfolgt über Kommandozeilenparameter (Lage der Konfigurationsdatei für MOA SP/SS, Lage der Konfigurationsdatei für das Logging mit Log4j). Detaillierte Informationen dazu finden Sie in der Quellcodedokumentation des Beispiels.
   Die Auswahl der zu prüfenden Signatur erfolgt ebenfalls per Kommandozeilenparameter. Detaillierte Informationen dazu finden Sie ebenfalls in der Quellcodedokumentation des Beispiels.

## 3.4 API-Dokumentation

Für die vollständige Dokumentation des API von MOA SP/SS sei auf die Java Doc der API verwiesen.

# A Referenzierte Software

Auf folgende Software-Pakete wird in diesem Handbuch verwiesen:

Name | Beschreibung
--- | ---
Apache Xerces 2 | XML-Parser aus dem Apache Project
Apache Axis | Webservice-Framework aus dem Apache Project
Java SE | Java Standard Edition (Software Development Kit bzw. Java Runtime Environment)

# B Referenzierte Spezifikation

Spezifikation | Link
--- | ---
Security Layer Spezifikation Version 1.2.7 | http://www.buergerkarte.at/konzept/securitylayer/spezifikation/20140114/core/core.html#core
PDF Spezifikation 1.7 | https://www.adobe.com/content/dam/acom/en/devnet/pdf/pdfs/PDF32000_2008.pdf