import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * @inheritDoc
 */
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws TransformationException {
    /**
     * If the actual input is an octet stream, then the application MUST
     * convert the octet stream to an XPath node-set suitable for use by
     * Canonical XML with Comments. (A subsequent application of the
     * REQUIRED Canonical XML algorithm would strip away these comments.)
     *
     * ...
     *
     * The evaluation of this expression includes all of the document's nodes
     * (including comments) in the node-set representing the octet stream.
     */

    Node signatureElement = transformObject.getElement();

    signatureElement = searchSignatureElement(signatureElement);
    input.setExcludeNode(signatureElement);
    input.addNodeFilter(new EnvelopedNodeFilter(signatureElement));
    return input;
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws CanonicalizationException {
    Canonicalizer20010315OmitComments c14n = new Canonicalizer20010315OmitComments();
    c14n.setSecureValidation(secureValidation);
    if (os != null) {
        c14n.setWriter(os);
    }
    byte[] result = null;
    result = c14n.engineCanonicalize(input);         		         	
    XMLSignatureInput output = new XMLSignatureInput(result);
    output.setSecureValidation(secureValidation);
    if (os != null) {
        output.setOutputStream(os);
    }
    return output;
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transform
) throws CanonicalizationException {
    Canonicalizer11_OmitComments c14n = new Canonicalizer11_OmitComments();
    c14n.setSecureValidation(secureValidation);
    if (os != null) {
        c14n.setWriter(os);
    }
    byte[] result = null;
    result = c14n.engineCanonicalize(input);         		         	
    XMLSignatureInput output = new XMLSignatureInput(result);
    output.setSecureValidation(secureValidation);
    if (os != null) {
        output.setOutputStream(os);
    }
    return output;
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/** @inheritDoc */
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws CanonicalizationException {

    Canonicalizer20010315WithComments c14n = new Canonicalizer20010315WithComments();
    c14n.setSecureValidation(secureValidation);
    if (os != null) {
        c14n.setWriter(os);
    }

    byte[] result = null;
    result = c14n.engineCanonicalize(input);         		         	
    XMLSignatureInput output = new XMLSignatureInput(result);
    output.setSecureValidation(secureValidation);
    if (os != null) {
        output.setOutputStream(os);
    }
    return output;
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transform
) throws CanonicalizationException {

    Canonicalizer11_WithComments c14n = new Canonicalizer11_WithComments();
    c14n.setSecureValidation(secureValidation);
    if (os != null) {
        c14n.setWriter(os);
    }

    byte[] result = null;
    result = c14n.engineCanonicalize(input);         		         	
    XMLSignatureInput output = new XMLSignatureInput(result);
    output.setSecureValidation(secureValidation);
    if (os != null) {
        output.setOutputStream(os);
    }
    return output;
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * Creates a Transform element for a given algorithm.
 * @param algorithm algorithm
 * @param parametersMarshallingProvider algorithm parameters marshaller
 * @param document the target XML document
 * @return the Transform
 * @throws UnsupportedAlgorithmException if the algorithm is not supported
 */
public static Transform createTransform(Algorithm algorithm, AlgorithmsParametersMarshallingProvider parametersMarshallingProvider, Document document) throws UnsupportedAlgorithmException
{
    List<Node> params = parametersMarshallingProvider.marshalParameters(algorithm, document);
    try
    {
        if (null == params)
        {
            return new Transform(document, algorithm.getUri());
        }
        else
        {
            return new Transform(document, algorithm.getUri(), DOMHelper.nodeList(params));
        }
    }
    catch (InvalidTransformException ex)
    {
        throw new UnsupportedAlgorithmException("C14N algorithm not supported in the XML Signature provider", algorithm.getUri(), ex);
    }
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
private void addToDigestInput(XMLSignatureInput refData, Document doc) throws CannotAddDataToDigestInputException
{
    try
    {
        if (refData.isNodeSet() || refData.isElement())
        {
            Transform c14nTransform = TransformUtils.createTransform(this.c14n, this.parametersMarshallingProvider, doc);
            refData = c14nTransform.performTransform(refData);
            // Fall through to add the bytes resulting from the canonicalization.
        }

        if (refData.isByteArray())
        {
            digestInput.write(refData.getBytes());
        } else if (refData.isOctetStream())
        {
            StreamUtils.readWrite(refData.getOctetStream(), digestInput);
        }
    }
    catch (Exception ex)
    {
        throw new CannotAddDataToDigestInputException(ex);
    }
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
private synchronized void
staticInit() {
    if (!staticallyInitialized) {
        org.apache.xml.security.Init.init();
        if (addJceProviders) {
            /*
             * The last provider added has precedence, that is if JuiCE can be added
             * then WSS4J uses this provider.
             */
            addJceProvider("BC", "org.bouncycastle.jce.provider.BouncyCastleProvider");
            addJceProvider("JuiCE", "org.apache.security.juice.provider.JuiCEProviderOpenSSL");
        }
        //Transform.init();
        try {
            Transform.register(
                STRTransform.implementedTransformURI,
                "org.apache.ws.security.transform.STRTransform"
            );
        } catch (Exception ex) {
            if (log.isDebugEnabled()) {
                log.debug(ex.getMessage(), ex);
            }
        }
        staticallyInitialized = true;
    }
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * Populate the inclusive namspace prefixes on the specified Apache (exclusive) transform object.
 * 
 * @param signature the Apache XMLSignature object
 * @param transform the Apache Transform object representing an exclusive transform
 */
private void processExclusiveTransform(XMLSignature signature, Transform transform) {
    // Namespaces that aren't visibly used, such as those used in QName attribute values, would
    // be stripped out by exclusive canonicalization. Need to make sure they aren't by explicitly
    // telling the transformer about them.
    log.debug("Adding list of inclusive namespaces for signature exclusive canonicalization transform");
    LazySet<String> inclusiveNamespacePrefixes = new LazySet<String>();
    populateNamespacePrefixes(inclusiveNamespacePrefixes, signableObject);
    
    if (inclusiveNamespacePrefixes != null && inclusiveNamespacePrefixes.size() > 0) {
        InclusiveNamespaces inclusiveNamespaces = new InclusiveNamespaces(signature.getDocument(),
                inclusiveNamespacePrefixes);
        transform.getElement().appendChild(inclusiveNamespaces.getElement());
    }
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * Method enginePerformTransform
 *
 * @param input
 * @return  {@link XMLSignatureInput} as the result of transformation
 * @throws TransformationException
 */
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws TransformationException {

    Object exArgs[] = { implementedTransformURI };

    throw new TransformationException("signature.Transform.NotYetImplemented", exArgs);
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws CanonicalizationException {
    try {
        String inclusiveNamespaces = null;

        if (transformObject.length(
            InclusiveNamespaces.ExclusiveCanonicalizationNamespace,
            InclusiveNamespaces._TAG_EC_INCLUSIVENAMESPACES) == 1
        ) {
            Element inclusiveElement =
                XMLUtils.selectNode(
                    transformObject.getElement().getFirstChild(),
                    InclusiveNamespaces.ExclusiveCanonicalizationNamespace,
                    InclusiveNamespaces._TAG_EC_INCLUSIVENAMESPACES,
                    0
                );

            inclusiveNamespaces =
                new InclusiveNamespaces(
                    inclusiveElement, transformObject.getBaseURI()
                ).getInclusiveNamespaces();
        }

        Canonicalizer20010315ExclWithComments c14n =
            new Canonicalizer20010315ExclWithComments();
        c14n.setSecureValidation(secureValidation);
        if (os != null) {
            c14n.setWriter(os);
        }
        byte[] result = c14n.engineCanonicalize(input, inclusiveNamespaces);
        XMLSignatureInput output = new XMLSignatureInput(result);
        output.setSecureValidation(secureValidation);

        return output;
    } catch (XMLSecurityException ex) {
        throw new CanonicalizationException(ex);
    }
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * Make sure Transform.performTransform does not throw NullPointerException.
 * See bug 41927 for more info.
 */
@org.junit.Test
public void test1() throws Exception {
    File file1  = null;
    File file2  = null;
    if (BASEDIR != null && !"".equals(BASEDIR)) {
        file1 = new File(BASEDIR + SEP + SOURCE_PATH, SIGNATURE_FILE);
        file2 = new File(BASEDIR + SEP + SOURCE_PATH, STYLESHEET_FILE);
    } else {
        file1 = new File(SOURCE_PATH, SIGNATURE_FILE);
        file1 = new File(SOURCE_PATH, STYLESHEET_FILE);
    }
    Document doc1 = getDocument(file1);
    Document doc2 = getDocument(file2);

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

    String expression = "//ds:Transform[1]";
    Element transformEl =
        (Element) xpath.evaluate(expression, doc1, XPathConstants.NODE);

    Transform transform =
        new Transform(doc1, Transforms.TRANSFORM_XSLT, transformEl.getChildNodes());

    transform.performTransform(new XMLSignatureInput(doc2));
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
public byte[] transform(final DSSDocument input) throws DSSException {
	try {
		final String dssTransformAlgorithm = dssTransform.getAlgorithm();
		final NodeList childNodes = document.getFirstChild().getChildNodes();
		final Transform transformObject = new Transform(document, dssTransformAlgorithm, childNodes);

		final byte[] bytes = DSSUtils.toByteArray(input);
		final XMLSignatureInput xmlSignatureInput = new XMLSignatureInput(bytes);
		final XMLSignatureInput xmlSignatureInputOut = transformObject.performTransform(xmlSignatureInput);
		return xmlSignatureInputOut.getBytes();
	} catch (Exception e) {
		throw new DSSException(e);
	}
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * Populate the inclusive namspace prefixes on the specified Apache (exclusive) transform object.
 * 
 * @param signature the Apache XMLSignature object
 * @param transform the Apache Transform object representing an exclusive transform
 */
private void processExclusiveTransform(XMLSignature signature, Transform transform) {
    // Namespaces that aren't visibly used, such as those used in QName attribute values, would
    // be stripped out by exclusive canonicalization. Need to make sure they aren't by explicitly
    // telling the transformer about them.
    log.debug("Adding list of inclusive namespaces for signature exclusive canonicalization transform");
    HashSet<String> inclusiveNamespacePrefixes = new HashSet<String>();
    populateNamespacePrefixes(inclusiveNamespacePrefixes, signableObject);
    
    if (inclusiveNamespacePrefixes != null && inclusiveNamespacePrefixes.size() > 0) {
        InclusiveNamespaces inclusiveNamespaces = new InclusiveNamespaces(signature.getDocument(),
                inclusiveNamespacePrefixes);
        transform.getElement().appendChild(inclusiveNamespaces.getElement());
    }
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
protected XMLSignatureInput enginePerformTransform(
        XMLSignatureInput input, OutputStream os, Transform _transformObject)
        throws IOException,
               CanonicalizationException, InvalidCanonicalizerException,
               TransformationException, ParserConfigurationException,
               SAXException {
        return enginePerformTransform(input, _transformObject);
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * Method enginePerformTransform
 * @inheritDoc
 * @param input
 *
 * @throws TransformationException
 */
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws TransformationException {
    try {
        /**
         * If the actual input is an octet stream, then the application MUST
         * convert the octet stream to an XPath node-set suitable for use by
         * Canonical XML with Comments. (A subsequent application of the
         * REQUIRED Canonical XML algorithm would strip away these comments.)
         *
         * ...
         *
         * The evaluation of this expression includes all of the document's nodes
         * (including comments) in the node-set representing the octet stream.
         */
        Element xpathElement =
            XMLUtils.selectDsNode(
                transformObject.getElement().getFirstChild(), Constants._TAG_XPATH, 0);

        if (xpathElement == null) {
            Object exArgs[] = { "ds:XPath", "Transform" };

            throw new TransformationException("xml.WrongContent", exArgs);
        }
        Node xpathnode = xpathElement.getFirstChild();
        String str = XMLUtils.getStrFromNode(xpathnode);
        input.setNeedsToBeExpanded(needsCircumvent(str));
        if (xpathnode == null) {
            throw new DOMException(
                DOMException.HIERARCHY_REQUEST_ERR, "Text must be in ds:Xpath"
            );
        }

        XPathFactory xpathFactory = XPathFactory.newInstance();
        XPathAPI xpathAPIInstance = xpathFactory.newXPathAPI();
        input.addNodeFilter(new XPathNodeFilter(xpathElement, xpathnode, str, xpathAPIInstance));
        input.setNodeSet(true);
        return input;
    } catch (DOMException ex) {
        throw new TransformationException(ex);
    }
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, OutputStream os, Transform transformObject
) throws CanonicalizationException {
    try {
        String inclusiveNamespaces = null;

        if (transformObject.length(
            InclusiveNamespaces.ExclusiveCanonicalizationNamespace,
            InclusiveNamespaces._TAG_EC_INCLUSIVENAMESPACES) == 1
        ) {
            Element inclusiveElement =
                XMLUtils.selectNode(
                    transformObject.getElement().getFirstChild(),
                    InclusiveNamespaces.ExclusiveCanonicalizationNamespace,
                    InclusiveNamespaces._TAG_EC_INCLUSIVENAMESPACES,
                    0
                );

            inclusiveNamespaces =
                new InclusiveNamespaces(
                    inclusiveElement, transformObject.getBaseURI()).getInclusiveNamespaces();
        }

        Canonicalizer20010315ExclOmitComments c14n =
            new Canonicalizer20010315ExclOmitComments();
        c14n.setSecureValidation(secureValidation);
        if (os != null) {
            c14n.setWriter(os);
        }
        byte[] result = c14n.engineCanonicalize(input, inclusiveNamespaces);

        XMLSignatureInput output = new XMLSignatureInput(result);
        output.setSecureValidation(secureValidation);
        if (os != null) {
            output.setOutputStream(os);
        }
        return output;
    } catch (XMLSecurityException ex) {
        throw new CanonicalizationException(ex);
    }
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * Dynamically initialise the library by registering the default algorithms/implementations
 */
private static void dynamicInit() {
    //
    // Load the Resource Bundle - the default is the English resource bundle.
    // To load another resource bundle, call I18n.init(...) before calling this
    // method.
    //
    I18n.init("en", "US");

    if (log.isDebugEnabled()) {
        log.debug("Registering default algorithms");
    }
    try {
        AccessController.doPrivileged(new PrivilegedExceptionAction<Void>(){
            @Override public Void run() throws XMLSecurityException {
                //
                // Bind the default prefixes
                //
                ElementProxy.registerDefaultPrefixes();

                //
                // Set the default Transforms
                //
                Transform.registerDefaultAlgorithms();

                //
                // Set the default signature algorithms
                //
                SignatureAlgorithm.registerDefaultAlgorithms();

                //
                // Set the default JCE algorithms
                //
                JCEMapper.registerDefaultAlgorithms();

                //
                // Set the default c14n algorithms
                //
                Canonicalizer.registerDefaultAlgorithms();

                //
                // Register the default resolvers
                //
                ResourceResolver.registerDefaultResolvers();

                //
                // Register the default key resolvers
                //
                KeyResolver.registerDefaultResolvers();

                return null;
            }
        });
    } catch (PrivilegedActionException ex) {
        XMLSecurityException xse = (XMLSecurityException)ex.getException();
        log.error(xse.getMessage(), xse);
    }
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * Method enginePerformTransform
 *
 * @param input
 * @return {@link XMLSignatureInput} as the result of transformation
 * @inheritDoc
 * @throws CanonicalizationException
 * @throws IOException
 * @throws TransformationException
 */
protected XMLSignatureInput enginePerformTransform(
    XMLSignatureInput input, Transform transformObject
) throws IOException, CanonicalizationException, TransformationException {
    return enginePerformTransform(input, null, transformObject);
}
 

import org.apache.xml.security.transforms.Transform; //导入依赖的package包/类
/**
 * Method enginePerformTransform
 *
 * @param input
 *
 */
protected XMLSignatureInput enginePerformTransform(XMLSignatureInput input, Transform _transformObject) {
    return input;
}