1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
/* * Copyright 2006 Sun Microsystems, Inc. All rights reserved. */ /* * $Id: DOMTransform.java,v 1.25 2005/05/10 18:15:34 mullan Exp $ */ package org.jcp.xml.dsig.internal.dom; import java.io.OutputStream; import java.security.InvalidAlgorithmParameterException; import java.security.NoSuchAlgorithmException; import java.security.spec.AlgorithmParameterSpec; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import javax.xml.crypto.*; import javax.xml.crypto.dsig.*; import javax.xml.crypto.dom.DOMCryptoContext; import javax.xml.crypto.dsig.dom.DOMSignContext; import javax.xml.crypto.dsig.spec.TransformParameterSpec; /** * DOM-based abstract implementation of Transform. * * @author Sean Mullan */ public class DOMTransform extends DOMStructure implements Transform { protected TransformService spi; /** * Creates a <code>DOMTransform</code>. * * @param spi the TransformService */ public DOMTransform(TransformService spi) { this.spi = spi; } /** * Creates a <code>DOMTransform</code> from an element. This constructor * invokes the abstract {@link #unmarshalParams unmarshalParams} method to * unmarshal any algorithm-specific input parameters. * * @param transElem a Transform element */ public DOMTransform(Element transElem, XMLCryptoContext context) throws MarshalException { Document ownerDoc = transElem.getOwnerDocument(); String algorithm = DOMUtils.getAttributeValue(transElem, "Algorithm"); try { spi = TransformService.getInstance(algorithm, "DOM"); } catch (NoSuchAlgorithmException e) { throw new MarshalException(e); } try { spi.init(new javax.xml.crypto.dom.DOMStructure(transElem), context); } catch (InvalidAlgorithmParameterException iape) { throw new MarshalException(iape); } } public final AlgorithmParameterSpec getParameterSpec() { return spi.getParameterSpec(); } public final String getAlgorithm() { return spi.getAlgorithm(); } /** * This method invokes the abstract {@link #marshalParams marshalParams} * method to marshal any algorithm-specific parameters. */ public void marshal(Node parent, String dsPrefix, DOMCryptoContext context) throws MarshalException { Document ownerDoc = DOMUtils.getOwnerDocument(parent); Element transformElem = null; if (parent.getLocalName().equals("Transforms")) { transformElem = DOMUtils.createElement (ownerDoc, "Transform", XMLSignature.XMLNS, dsPrefix); } else { transformElem = DOMUtils.createElement (ownerDoc, "CanonicalizationMethod", XMLSignature.XMLNS, dsPrefix); } DOMUtils.setAttribute(transformElem, "Algorithm", getAlgorithm()); spi.marshalParams (new javax.xml.crypto.dom.DOMStructure(transformElem), context); parent.appendChild(transformElem); } /** * Transforms the specified data using the underlying transform algorithm. * * @param data the data to be transformed * @param sc the <code>XMLCryptoContext</code> containing * additional context (may be <code>null</code> if not applicable) * @return the transformed data * @throws NullPointerException if <code>data</code> is <code>null</code> * @throws XMLSignatureException if an unexpected error occurs while * executing the transform */ public Data transform(Data data, XMLCryptoContext xc) throws TransformException { return spi.transform(data, xc); } /** * Transforms the specified data using the underlying transform algorithm. * * @param data the data to be transformed * @param sc the <code>XMLCryptoContext</code> containing * additional context (may be <code>null</code> if not applicable) * @param os the <code>OutputStream</code> that should be used to write * the transformed data to * @return the transformed data * @throws NullPointerException if <code>data</code> is <code>null</code> * @throws XMLSignatureException if an unexpected error occurs while * executing the transform */ public Data transform(Data data, XMLCryptoContext xc, OutputStream os) throws TransformException { return spi.transform(data, xc, os); } public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof Transform)) { return false; } Transform otransform = (Transform) o; return (getAlgorithm().equals(otransform.getAlgorithm()) && DOMUtils.paramsEqual (getParameterSpec(), otransform.getParameterSpec())); } /** * Transforms the specified data using the underlying transform algorithm. * This method invokes the {@link #marshal marshal} method and passes it * the specified <code>DOMSignContext</code> before transforming the data. * * @param data the data to be transformed * @param sc the <code>XMLCryptoContext</code> containing * additional context (may be <code>null</code> if not applicable) * @param context the marshalling context * @return the transformed data * @throws MarshalException if an exception occurs while marshalling * @throws NullPointerException if <code>data</code> or <code>context</code> * is <code>null</code> * @throws XMLSignatureException if an unexpected error occurs while * executing the transform */ Data transform(Data data, XMLCryptoContext xc, DOMSignContext context) throws MarshalException, TransformException { marshal(context.getParent(), DOMUtils.getSignaturePrefix(context), context); return transform(data, xc); } }