Implementowanie interfejsu IURIDereferencer

Podczas generowania podpisu XML w kopercie elementy podpisu są wstawiane do podpisywanych danych. Na przykład, jeśli podpiszemy następującą wiadomość przy użyciu struktury podpisu w kopercie:

<message> 
    <data>...</data> 
</message>

...wynikowy podpisany dokument będzie miał następującą postać:

<message> 
    <data>...</data> 
     <Signature xmlns="http://www.w3.org/2000/09/xmldsig#"> 
        <SignedInfo> 
            <CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/> 
            <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/> 
            <Reference URI=""> 
                <Transforms> 
                    <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/> 
                </Transforms> 
                <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/> 
                <DigestValue>yv6...Z0Y=</DigestValue> 
            </Reference> 
        </SignedInfo> 
        <SignatureValue>cCY...LQ==</SignatureValue> 
        <KeyInfo> 
            <X509Data> 
                <X509Certificate>MII...4e</X509Certificate> 
            </X509Data> 
        </KeyInfo> 
    </Signature> 
</message>

Należy zwrócić uwagę, że podpis zawiera pojedynczy element Reference z pustym ciągiem znaków jako identyfikatorem URI. Pusty ciąg znaków w tym kontekście oznacza początek dokumentu.

Należy także zwrócić uwagę, że algorytm transformacji wymusza zastosowanie transformacji podpisu w kopercie. Zastosowanie transformacji podpisu w kopercie powoduje, że obiekt XMLSignatureValidator automatycznie usuwa podpis z dokumentu przed obliczeniem wyciągu. Oznacza to, że obiekt tłumaczący odwołania nie musi usuwać elementu Signature ze zwracanych danych:

Poniższy przykład ilustruje klasę tłumaczącą odwołania dla podpisów w kopercie:

package 
{ 
    import flash.events.ErrorEvent; 
      import flash.events.EventDispatcher;  
    import flash.security.IURIDereferencer; 
    import flash.utils.ByteArray; 
    import flash.utils.IDataInput; 
 
    public class EnvelopedDereferencer 
        extends EventDispatcher implements IURIDereferencer 
    { 
        private var signedMessage:XML; 
         
        public function EnvelopedDereferencer( signedMessage:XML ) 
        { 
            this.signedMessage = signedMessage; 
        } 
 
        public function dereference( uri:String ):IDataInput 
        { 
            try 
            { 
                if( uri.length != 0 ) 
                { 
                    throw( new Error("Unsupported signature type.") ); 
                } 
                var data:ByteArray = new ByteArray(); 
                data.writeUTFBytes( signedMessage.toXMLString() ); 
                data.position = 0; 
            } 
            catch (e:Error) 
                { 
                var error:ErrorEvent = 
                    new ErrorEvent("Ref error " + uri + " ", false, false, e.message); 
                this.dispatchEvent(error); 
                data = null; 
                throw new Error("Reference not resolvable: " + uri + ", " + e.message); 
            } 
            finally 
            { 
                return data; 
            } 
        }         
    } 
}

Klasa tłumacząca odwołania ma konstruktor z parametrem signedMessage , który udostępnia podpis w kopercie metodzie dereference() . Ponieważ odwołanie w podpisie w kopercie zawsze wskazuje na początek podpisywanych danych, metoda dereferencer() zapisuje dokument w tablicy bajtów i zwraca tę tablicę.

Gdy podpisane dane są umieszczone w tym samym dokumencie, co sam podpis, identyfikatory URI w odwołaniach zazwyczaj zbudowane są zgodnie ze składnią XPath lub XPointer, adresując podpisane elementy. W zaleceniach W3C dotyczące składni i przetwarzania podpisów XML składnia ta nie jest traktowana jako obowiązkowa, lecz jako zalecana, dlatego własną implementację należy opracować pod kątem podpisów, jakie najprawdopodobniej napotka aplikacja (i uzupełnić o mechanizmy obsługi błędów prawidłowo reagujące na nieobsługiwaną składnię).

Przykładem podpisu typu koperta jest podpis aplikacji AIR. Pliki wchodzące w skład aplikacji są wymienione w elemencie Manifest. Adres elementu Manifest jest podany w atrybucie URI elementu Reference w postaci ciągu znaków „#PackageContents”, który odwołuje się do identyfikatora elementu Manifest:

<Signature xmlns="http://www.w3.org/2000/09/xmldsig#" Id="PackageSignature"> 
    <SignedInfo> 
        <CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/> 
        <SignatureMethod Algorithm="http://www.w3.org/TR/xmldsig-core#rsa-sha1"/> 
        <Reference URI="#PackageContents"> 
            <Transforms> 
                <Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/> 
            </Transforms> 
            <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/> 
            <DigestValue>ZMGqQdaRKQc1HirIRsDpeBDlaElS+pPotdziIAyAYDk=</DigestValue> 
        </Reference> 
    </SignedInfo> 
    <SignatureValue Id="PackageSignatureValue">cQK...7Zg==</SignatureValue> 
    <KeyInfo> 
        <X509Data> 
            <X509Certificate>MII...T4e</X509Certificate> 
        </X509Data> 
    </KeyInfo> 
    <Object> 
    <Manifest Id="PackageContents"> 
        <Reference URI="mimetype"> 
            <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"> 
            </DigestMethod> 
            <DigestValue>0/oCb84THKMagtI0Dy0KogEu92TegdesqRr/clXct1c=</DigestValue> 
        </Reference> 
        <Reference URI="META-INF/AIR/application.xml"> 
            <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"> 
            </DigestMethod> 
            <DigestValue>P9MqtqSdqcqnFgeoHCJysLQu4PmbUW2JdAnc1WLq8h4=</DigestValue> 
        </Reference> 
        <Reference URI="XMLSignatureValidation.swf"> 
            <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"> 
            </DigestMethod> 
            <DigestValue>OliRHRAgc9qt3Dk0m0Bi53Ur5ur3fAweIFwju74rFgE=</DigestValue> 
        </Reference> 
    </Manifest> 
</Object> 
</Signature>

Obiekt tłumaczący odwołania podczas weryfikacji tego podpisu musi pobrać identyfikator URI zawierający ciąg "#PackageContents" z elementu Reference i zwrócić element Manifest w obiekcie ByteArray. Symbol „#” oznacza wartość atrybutu Id elementu.

W poniższym przykładzie zaimplementowano klasę tłumaczącą odwołania na potrzeby weryfikacji podpisów aplikacji AIR. Implementacja jest prosta, ponieważ bazuje na znanej strukturze podpisu aplikacji AIR. Uniwersalna klasa tłumacząca odwołania byłaby znacznie bardziej skomplikowania.

package 
{ 
    import flash.events.ErrorEvent;    
    import flash.security.IURIDereferencer; 
    import flash.utils.ByteArray; 
    import flash.utils.IDataInput; 
     
    public class AIRSignatureDereferencer implements IURIDereferencer { 
        private const XML_SIG_NS:Namespace = 
            new Namespace( "http://www.w3.org/2000/09/xmldsig#" ); 
        private var airSignature:XML; 
     
        public function AIRSignatureDereferencer( airSignature:XML ) { 
            this.airSignature = airSignature; 
        } 
         
        public function dereference( uri:String ):IDataInput {     
            var data:ByteArray = null;     
            try 
            {     
                if( uri != "#PackageContents" ) 
                { 
                    throw( new Error("Unsupported signature type.") ); 
                } 
                var manifest:XMLList = 
                    airSignature.XML_SIG_NS::Object.XML_SIG_NS::Manifest; 
                data = new ByteArray(); 
                data.writeUTFBytes( manifest.toXMLString()); 
                data.position = 0; 
            } 
            catch (e:Error) 
            { 
                data = null; 
                throw new Error("Reference not resolvable: " + uri + ", " + e.message); 
            } 
            finally 
            { 
                return data; 
            } 
             
        } 
    } 
}

Podczas weryfikacji podpisu tego typu sprawdzane są wyłącznie dane w elemencie Manifest. Faktyczne pliki w pakiecie nie są w ogóle weryfikowane. Aby sprawdzić, czy pliki w pakiecie nie zostały zmodyfikowane, należy je wczytać, obliczyć wyciąg SHA256 i porównać wynik z wyciągiem zarejestrowanym w manifeście. Klasa XMLSignatureValidator nie sprawdza automatycznie takich odwołań drugiego poziomu.

Gdy identyfikator URI odwołuje się do zasobu zewnętrznego, konieczne jest uzyskanie dostępu do tych danych i załadowanie ich do obiektu ByteArray. Jeśli identyfikator URI zawiera bezwzględny adres URL, operacja ta sprowadza się do wczytania pliku lub zażądania danych spod adresu URL. Jeśli, co zdarza się częściej, identyfikator URI zawiera ścieżkę względną, implementacja interfejsu IURIDereferencer musi zawierać mechanizm tłumaczący ścieżki na bezwzględne położenia podpisanych plików.

W poniższym przykładzie użyto obiektu File inicjowanego podczas konstruowania instancji klasy tłumaczącej odwołania. Obiekt ten stanowi podstawę do tłumaczenia położeń podpisanych plików.

package 
{ 
    import flash.events.ErrorEvent; 
    import flash.events.EventDispatcher; 
    import flash.filesystem.File; 
    import flash.filesystem.FileMode; 
    import flash.filesystem.FileStream; 
    import flash.security.IURIDereferencer; 
    import flash.utils.ByteArray; 
    import flash.utils.IDataInput; 
    public class RelativeFileDereferencer 
        extends EventDispatcher implements IURIDereferencer 
    { 
        private var base:File; 
         
        public function RelativeFileDereferencer( base:File ) 
        { 
            this.base = base; 
        } 
 
        public function dereference( uri:String ):IDataInput 
        { 
            var data:ByteArray = null; 
            try{ 
                var referent:File = this.base.resolvePath( uri ); 
                var refStream:FileStream = new FileStream();             
                data = new ByteArray(); 
                refStream.open( referent, FileMode.READ ); 
                 
                refStream.readBytes( data, 0, data.bytesAvailable ); 
                 
            } catch ( e:Error ) { 
                data = null; 
                throw new Error("Reference not resolvable: " + referent.nativePath + ", " + e.message ); 
            } finally { 
                return data; 
            } 
        }         
    } 
}

Funkcja dereference() znajduje plik adresowany przez identyfikator URI odwołania, ładuje treść pliku do tablicy bajtów i zwraca obiekt ByteArray.