Java XPathContainer类代码示例

import org.apache.xml.security.transforms.params.XPathContainer; //导入依赖的package包/类
@Override
public List<Node> marshalParameters(XPathTransform alg, Document doc)
{
    XPathContainer xpathContainer = new XPathContainer(doc);
    xpathContainer.setXPath(alg.getXPath());
            
    for(Map.Entry<String, String> ns : alg.getNamespaces().entrySet())
    {
        try 
        {
            xpathContainer.setXPathNamespaceContext(ns.getKey(), ns.getValue());
        }catch (XMLSecurityException ex) 
        {
            throw new IllegalArgumentException("Invalid namespaces for XPath query", ex);
        }
    }

    return Collections.singletonList((Node)xpathContainer.getElement());
}
 

import org.apache.xml.security.transforms.params.XPathContainer; //导入依赖的package包/类
private void checkXmlSignatureSoftwareStack(boolean cert) throws Exception {
    Init.init();
    DocumentBuilder documentBuilder = XMLUtils.createDocumentBuilder(false);
    Document testDocument = documentBuilder.newDocument();

    Element rootElement =
        testDocument.createElementNS("urn:namespace", "tns:document");
    rootElement.setAttributeNS
        (Constants.NamespaceSpecNS, "xmlns:tns", "urn:namespace");
    testDocument.appendChild(rootElement);
    Element childElement =
        testDocument.createElementNS("urn:childnamespace", "t:child");
    childElement.setAttributeNS
        (Constants.NamespaceSpecNS, "xmlns:t", "urn:childnamespace");
    childElement.appendChild(testDocument.createTextNode("hello world"));
    rootElement.appendChild(childElement);

    PrivateKey privateKey = null;
    PublicKey publicKey = null;
    X509Certificate signingCert = null;
    if (cert) {
        // get key & self-signed certificate from keystore
        String fs = System.getProperty("file.separator");
        FileInputStream fis =
            new FileInputStream(BASEDIR + fs + "src/test/resources" + fs + "test.jks");
        KeyStore ks = KeyStore.getInstance("JKS");
        ks.load(fis, "changeit".toCharArray());
        signingCert = (X509Certificate) ks.getCertificate("mullan");
        publicKey = signingCert.getPublicKey();
        privateKey = (PrivateKey) ks.getKey("mullan", "changeit".toCharArray());
    } else {
        KeyPair keyPair = KeyPairGenerator.getInstance("DSA").generateKeyPair();
        publicKey = keyPair.getPublic();
        privateKey = keyPair.getPrivate();
    }

    XMLSignature signature =
        new XMLSignature(
            testDocument, "", XMLSignature.ALGO_ID_SIGNATURE_DSA,
            Canonicalizer.ALGO_ID_C14N_WITH_COMMENTS
        );

    Element signatureElement = signature.getElement();
    rootElement.appendChild(signatureElement);

    Transforms transforms = new Transforms(testDocument);
    XPathContainer xpath = new XPathContainer(testDocument);
    xpath.setXPathNamespaceContext("ds", Constants.SignatureSpecNS);
    xpath.setXPath("not(ancestor-or-self::ds:Signature)");
    transforms.addTransform(Transforms.TRANSFORM_XPATH, xpath.getElementPlusReturns());
    transforms.addTransform(Transforms.TRANSFORM_C14N_WITH_COMMENTS);
    signature.addDocument("", transforms, MessageDigestAlgorithm.ALGO_ID_DIGEST_SHA1);

    if (cert) {
        signature.addKeyInfo(signingCert);
    } else {
        signature.addKeyInfo(publicKey);
    }

    Element nsElement = testDocument.createElementNS(null, "nsElement");
    nsElement.setAttributeNS(
        Constants.NamespaceSpecNS, "xmlns:ds", Constants.SignatureSpecNS
    );

    signature.sign(privateKey);

    XPathFactory xpf = XPathFactory.newInstance();
    XPath xPath = xpf.newXPath();
    xPath.setNamespaceContext(new DSNamespaceContext());

    String expression = "//ds:Signature[1]";
    Element sigElement =
        (Element) xPath.evaluate(expression, testDocument, XPathConstants.NODE);

    XMLSignature signatureToVerify = new XMLSignature(sigElement, "");

    boolean signResult = signatureToVerify.checkSignatureValue(publicKey);

    assertTrue(signResult);
}
 

import org.apache.xml.security.transforms.params.XPathContainer; //导入依赖的package包/类
/**
 * Test for bug 36044 - Canonicalizing an empty node-set throws an
 * ArrayIndexOutOfBoundsException.
 */
@org.junit.Test
public void testEmptyNodeSet() throws Exception {
    Document doc = db.newDocument();
    Element envelope = doc.createElementNS("http://www.usps.gov/", "Envelope");
    envelope.appendChild(doc.createTextNode("\n"));
    doc.appendChild(envelope);

    XMLSignature sig =
        new XMLSignature(doc, null, XMLSignature.ALGO_ID_SIGNATURE_DSA);
    envelope.appendChild(sig.getElement());

    ObjectContainer object1 = new ObjectContainer(doc);
    object1.setId("object-1");
    object1.setMimeType("text/plain");
    sig.appendObject(object1);

    ObjectContainer object2 = new ObjectContainer(doc);

    object2.setId("object-2");
    object2.setMimeType("text/plain");
    object2.setEncoding("http://www.w3.org/2000/09/xmldsig#base64");
    object2.appendChild(doc.createTextNode("SSBhbSB0aGUgdGV4dC4="));
    sig.appendObject(object2);

    Transforms transforms = new Transforms(doc);
    XPathContainer xpathC = new XPathContainer(doc);

    xpathC.setXPath("self::text()");
    transforms.addTransform(Transforms.TRANSFORM_XPATH, xpathC.getElementPlusReturns());
    sig.addDocument(
        "#object-1", transforms, Constants.ALGO_ID_DIGEST_SHA1, null,
        "http://www.w3.org/2000/09/xmldsig#Object"
    );

    KeyStore ks = KeyStore.getInstance("JKS");
    FileInputStream fis = null;
    if (BASEDIR != null && !"".equals(BASEDIR)) {
        fis =
            new FileInputStream(BASEDIR + SEP
                + "src/test/resources/org/apache/xml/security/samples/input/keystore.jks"
            );
    } else {
        fis =
            new FileInputStream("src/test/resources/org/apache/xml/security/samples/input/keystore.jks");
    }
    ks.load(fis, "xmlsecurity".toCharArray());
    PrivateKey privateKey = (PrivateKey) ks.getKey("test", "xmlsecurity".toCharArray());

    sig.sign(privateKey);
}
 

import org.apache.xml.security.transforms.params.XPathContainer; //导入依赖的package包/类
@org.junit.Test
public void testSameDocumentCipherReference() throws Exception {

    if (haveISOPadding) {
        DocumentBuilder db = XMLUtils.createDocumentBuilder(false);

        Document d = db.newDocument();

        Element docElement = d.createElement("EncryptedDoc");
        d.appendChild(docElement);

        // Create the XMLCipher object
        cipher = XMLCipher.getInstance();

        EncryptedData ed =
            cipher.createEncryptedData(CipherData.REFERENCE_TYPE,
                                       "#CipherTextId");
        EncryptionMethod em =
            cipher.createEncryptionMethod(XMLCipher.AES_128);

        ed.setEncryptionMethod(em);

        org.apache.xml.security.encryption.Transforms xencTransforms =
            cipher.createTransforms(d);
        ed.getCipherData().getCipherReference().setTransforms(xencTransforms);
        org.apache.xml.security.transforms.Transforms dsTransforms =
            xencTransforms.getDSTransforms();

        // An XPath transform
        XPathContainer xpc = new XPathContainer(d);
        xpc.setXPath("self::text()[parent::CipherText[@Id=\"CipherTextId\"]]");
        dsTransforms.addTransform(
            org.apache.xml.security.transforms.Transforms.TRANSFORM_XPATH,
            xpc.getElementPlusReturns()
        );

        // Add a Base64 Transforms
        dsTransforms.addTransform(
            org.apache.xml.security.transforms.Transforms.TRANSFORM_BASE64_DECODE
        );

        Element ee = cipher.martial(d, ed);

        docElement.appendChild(ee);

        // Add the cipher text
        Element encryptedElement = d.createElement("CipherText");
        encryptedElement.setAttributeNS(null, "Id", "CipherTextId");
        encryptedElement.setIdAttributeNS(null, "Id", true);
        encryptedElement.appendChild(d.createTextNode(tstBase64EncodedString));
        docElement.appendChild(encryptedElement);
        // dump(d);

        // Now the decrypt, with a brand new cipher
        XMLCipher cipherDecrypt = XMLCipher.getInstance();
        Key key = new SecretKeySpec("abcdefghijklmnop".getBytes("ASCII"), "AES");

        cipherDecrypt.init(XMLCipher.DECRYPT_MODE, key);
        byte[] decryptBytes = cipherDecrypt.decryptToByteArray(ee);

        assertEquals("A test encrypted secret",
                    new String(decryptBytes, "ASCII"));
    } else {
        log.warn(
            "Test testSameDocumentCipherReference skipped as "
            + "necessary algorithms not available"
        );
    }
}