com.sun.org.apache.xml.internal.security.c14n.Canonicalizer Java Examples

public Data transform(Data data, XMLCryptoContext xc)
    throws TransformException {

    // ignore comments if dereferencing same-document URI that requires
    // you to omit comments, even if the Transform says otherwise -
    // this is to be compliant with section 4.3.3.3 of W3C Rec.
    if (data instanceof DOMSubTreeData) {
        DOMSubTreeData subTree = (DOMSubTreeData) data;
        if (subTree.excludeComments()) {
            try {
                apacheCanonicalizer = Canonicalizer.getInstance
                    (CanonicalizationMethod.INCLUSIVE);
            } catch (InvalidCanonicalizerException ice) {
                throw new TransformException
                    ("Couldn't find Canonicalizer for: " +
                     CanonicalizationMethod.INCLUSIVE + ": " +
                     ice.getMessage(), ice);
            }
        }
    }

    return canonicalize(data, xc);
}
 

/**
 * Output the C14n stream to the given OutputStream.
 * @param os
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public void signInOctetStream(OutputStream os)
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());
        c14nizer.setWriter(os);
        String inclusiveNamespaces = this.getInclusiveNamespaces();

        if (inclusiveNamespaces == null) {
            c14nizer.canonicalizeSubtree(this.constructionElement);
        } else {
            c14nizer.canonicalizeSubtree(this.constructionElement, inclusiveNamespaces);
        }
    } else {
        try {
            os.write(this.c14nizedBytes);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
 

/**
 * Output the C14n stream to the given OutputStream.
 * @param os
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public void signInOctetStream(OutputStream os)
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());
        c14nizer.setWriter(os);
        String inclusiveNamespaces = this.getInclusiveNamespaces();

        if (inclusiveNamespaces == null) {
            c14nizer.canonicalizeSubtree(this.constructionElement);
        } else {
            c14nizer.canonicalizeSubtree(this.constructionElement, inclusiveNamespaces);
        }
    } else {
        try {
            os.write(this.c14nizedBytes);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
 

/**
 * Output the C14n stream to the given OutputStream.
 * @param os
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public void signInOctetStream(OutputStream os)
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());
        c14nizer.setWriter(os);
        String inclusiveNamespaces = this.getInclusiveNamespaces();

        if (inclusiveNamespaces == null) {
            c14nizer.canonicalizeSubtree(this.constructionElement);
        } else {
            c14nizer.canonicalizeSubtree(this.constructionElement, inclusiveNamespaces);
        }
    } else {
        try {
            os.write(this.c14nizedBytes);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
 

public Data transform(Data data, XMLCryptoContext xc)
    throws TransformException {

    // ignore comments if dereferencing same-document URI that requires
    // you to omit comments, even if the Transform says otherwise -
    // this is to be compliant with section 4.3.3.3 of W3C Rec.
    if (data instanceof DOMSubTreeData) {
        DOMSubTreeData subTree = (DOMSubTreeData) data;
        if (subTree.excludeComments()) {
            try {
                apacheCanonicalizer = Canonicalizer.getInstance
                    (CanonicalizationMethod.INCLUSIVE);
            } catch (InvalidCanonicalizerException ice) {
                throw new TransformException
                    ("Couldn't find Canonicalizer for: " +
                     CanonicalizationMethod.INCLUSIVE + ": " +
                     ice.getMessage(), ice);
            }
        }
    }

    return canonicalize(data, xc);
}
 

/**
 * Output the C14n stream to the given OutputStream.
 * @param os
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public void signInOctetStream(OutputStream os)
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());
        c14nizer.setWriter(os);
        String inclusiveNamespaces = this.getInclusiveNamespaces();

        if (inclusiveNamespaces == null) {
            c14nizer.canonicalizeSubtree(this.constructionElement);
        } else {
            c14nizer.canonicalizeSubtree(this.constructionElement, inclusiveNamespaces);
        }
    } else {
        try {
            os.write(this.c14nizedBytes);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
 

private static void generate_hmac_sha1_40() throws Exception {
    System.out.println("Generating ");

    Document doc = dbf.newDocumentBuilder().newDocument();
    XMLSignature sig = new XMLSignature
        (doc, null, XMLSignature.ALGO_ID_MAC_HMAC_SHA1, 40,
         Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS);
    try {
        sig.sign(getSecretKey("secret".getBytes("ASCII")));
        System.out.println("FAILED");
        atLeastOneFailed = true;
    } catch (XMLSignatureException xse) {
        System.out.println(xse.getMessage());
        System.out.println("PASSED");
    }
}
 

public Data transform(Data data, XMLCryptoContext xc)
    throws TransformException {

    // ignore comments if dereferencing same-document URI that requires
    // you to omit comments, even if the Transform says otherwise -
    // this is to be compliant with section 4.3.3.3 of W3C Rec.
    if (data instanceof DOMSubTreeData) {
        DOMSubTreeData subTree = (DOMSubTreeData) data;
        if (subTree.excludeComments()) {
            try {
                apacheCanonicalizer = Canonicalizer.getInstance(C14N_11);
            } catch (InvalidCanonicalizerException ice) {
                throw new TransformException
                    ("Couldn't find Canonicalizer for: " +
                     C14N_11 + ": " + ice.getMessage(), ice);
            }
        }
    }

    return canonicalize(data, xc);
}
 

private static void generate_hmac_sha1_40() throws Exception {
    System.out.println("Generating ");

    Document doc = dbf.newDocumentBuilder().newDocument();
    XMLSignature sig = new XMLSignature
        (doc, null, XMLSignature.ALGO_ID_MAC_HMAC_SHA1, 40,
         Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS);
    try {
        sig.sign(getSecretKey("secret".getBytes("ASCII")));
        System.out.println("FAILED");
        atLeastOneFailed = true;
    } catch (XMLSignatureException xse) {
        System.out.println(xse.getMessage());
        System.out.println("PASSED");
    }
}
 

public Data transform(Data data, XMLCryptoContext xc)
    throws TransformException {

    // ignore comments if dereferencing same-document URI that requires
    // you to omit comments, even if the Transform says otherwise -
    // this is to be compliant with section 4.3.3.3 of W3C Rec.
    if (data instanceof DOMSubTreeData) {
        DOMSubTreeData subTree = (DOMSubTreeData) data;
        if (subTree.excludeComments()) {
            try {
                apacheCanonicalizer = Canonicalizer.getInstance
                    (CanonicalizationMethod.INCLUSIVE);
            } catch (InvalidCanonicalizerException ice) {
                throw new TransformException
                    ("Couldn't find Canonicalizer for: " +
                     CanonicalizationMethod.INCLUSIVE + ": " +
                     ice.getMessage(), ice);
            }
        }
    }

    return canonicalize(data, xc);
}
 

public Data transform(Data data, XMLCryptoContext xc)
    throws TransformException {

    // ignore comments if dereferencing same-document URI that requires
    // you to omit comments, even if the Transform says otherwise -
    // this is to be compliant with section 4.3.3.3 of W3C Rec.
    if (data instanceof DOMSubTreeData) {
        DOMSubTreeData subTree = (DOMSubTreeData) data;
        if (subTree.excludeComments()) {
            try {
                apacheCanonicalizer = Canonicalizer.getInstance
                    (CanonicalizationMethod.INCLUSIVE);
            } catch (InvalidCanonicalizerException ice) {
                throw new TransformException
                    ("Couldn't find Canonicalizer for: " +
                     CanonicalizationMethod.INCLUSIVE + ": " +
                     ice.getMessage(), ice);
            }
        }
    }

    return canonicalize(data, xc);
}
 

private static void generate_hmac_sha1_40() throws Exception {
    System.out.println("Generating ");

    Document doc = dbf.newDocumentBuilder().newDocument();
    XMLSignature sig = new XMLSignature
        (doc, null, XMLSignature.ALGO_ID_MAC_HMAC_SHA1, 40,
         Canonicalizer.ALGO_ID_C14N_OMIT_COMMENTS);
    try {
        sig.sign(getSecretKey("secret".getBytes("ASCII")));
        System.out.println("FAILED");
        atLeastOneFailed = true;
    } catch (XMLSignatureException xse) {
        System.out.println(xse.getMessage());
        System.out.println("PASSED");
    }
}
 

/**
 * Output the C14n stream to the given OutputStream.
 * @param os
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public void signInOctetStream(OutputStream os)
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());
        c14nizer.setWriter(os);
        String inclusiveNamespaces = this.getInclusiveNamespaces();

        if (inclusiveNamespaces == null) {
            c14nizer.canonicalizeSubtree(this.constructionElement);
        } else {
            c14nizer.canonicalizeSubtree(this.constructionElement, inclusiveNamespaces);
        }
    } else {
        try {
            os.write(this.c14nizedBytes);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
 

public Data transform(Data data, XMLCryptoContext xc)
    throws TransformException
{
    // ignore comments if dereferencing same-document URI that require
    // you to omit comments, even if the Transform says otherwise -
    // this is to be compliant with section 4.3.3.3 of W3C Rec.
    if (data instanceof DOMSubTreeData) {
        DOMSubTreeData subTree = (DOMSubTreeData)data;
        if (subTree.excludeComments()) {
            try {
                apacheCanonicalizer = Canonicalizer.getInstance
                    (CanonicalizationMethod.EXCLUSIVE);
            } catch (InvalidCanonicalizerException ice) {
                throw new TransformException
                    ("Couldn't find Canonicalizer for: " +
                     CanonicalizationMethod.EXCLUSIVE + ": " +
                     ice.getMessage(), ice);
            }
        }
    }

    return canonicalize(data, xc);
}
 

/**
 * Returns getCanonicalizedOctetStream
 *
 * @return the canonicalization result octet stream of <code>SignedInfo</code> element
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public byte[] getCanonicalizedOctetStream()
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());

        this.c14nizedBytes =
            c14nizer.canonicalizeSubtree(this.constructionElement);
    }

    // make defensive copy
    return this.c14nizedBytes.clone();
}
 

/**
 * Returns getCanonicalizedOctetStream
 *
 * @return the canonicalization result octet stream of <code>SignedInfo</code> element
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public byte[] getCanonicalizedOctetStream()
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());

        this.c14nizedBytes =
            c14nizer.canonicalizeSubtree(this.constructionElement);
    }

    // make defensive copy
    return this.c14nizedBytes.clone();
}
 

/**
 * Creates a new <code>XMLCipher</code>.
 *
 * @param transformation    the name of the transformation, e.g.,
 *                          <code>XMLCipher.TRIPLEDES</code>. If null the XMLCipher can only
 *                          be used for decrypt or unwrap operations where the encryption method
 *                          is defined in the <code>EncryptionMethod</code> element.
 * @param provider          the JCE provider that supplies the transformation,
 *                          if null use the default provider.
 * @param canon             the name of the c14n algorithm, if
 *                          <code>null</code> use standard serializer
 * @param digestMethod      An optional digestMethod to use.
 */
private XMLCipher(
    String transformation,
    String provider,
    String canonAlg,
    String digestMethod
) throws XMLEncryptionException {
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Constructing XMLCipher...");
    }

    factory = new Factory();

    algorithm = transformation;
    requestedJCEProvider = provider;
    digestAlg = digestMethod;

    // Create a canonicalizer - used when serializing DOM to octets
    // prior to encryption (and for the reverse)

    try {
        if (canonAlg == null) {
            // The default is to preserve the physical representation.
            this.canon = Canonicalizer.getInstance(Canonicalizer.ALGO_ID_C14N_PHYSICAL);
        } else {
            this.canon = Canonicalizer.getInstance(canonAlg);
        }
    } catch (InvalidCanonicalizerException ice) {
        throw new XMLEncryptionException("empty", ice);
    }

    if (serializer == null) {
        serializer = new DocumentSerializer();
    }
    serializer.setCanonicalizer(this.canon);

    if (transformation != null) {
        contextCipher = constructCipher(transformation, digestMethod);
    }
}
 

/**
 * Returns getCanonicalizedOctetStream
 *
 * @return the canonicalization result octet stream of <code>SignedInfo</code> element
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public byte[] getCanonicalizedOctetStream()
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());

        this.c14nizedBytes =
            c14nizer.canonicalizeSubtree(this.constructionElement);
    }

    // make defensive copy
    return this.c14nizedBytes.clone();
}
 

/**
 * Returns getCanonicalizedOctetStream
 *
 * @return the canonicalization result octet stream of <code>SignedInfo</code> element
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public byte[] getCanonicalizedOctetStream()
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());

        this.c14nizedBytes =
            c14nizer.canonicalizeSubtree(this.constructionElement);
    }

    // make defensive copy
    return this.c14nizedBytes.clone();
}
 

/**
 * Returns getCanonicalizedOctetStream
 *
 * @return the canonicalization result octet stream of <code>SignedInfo</code> element
 * @throws CanonicalizationException
 * @throws InvalidCanonicalizerException
 * @throws XMLSecurityException
 */
public byte[] getCanonicalizedOctetStream()
    throws CanonicalizationException, InvalidCanonicalizerException, XMLSecurityException {
    if (this.c14nizedBytes == null) {
        Canonicalizer c14nizer =
            Canonicalizer.getInstance(this.getCanonicalizationMethodURI());

        this.c14nizedBytes =
            c14nizer.canonicalizeSubtree(this.constructionElement);
    }

    // make defensive copy
    return this.c14nizedBytes.clone();
}
 

/**
 * Creates a new <code>XMLCipher</code>.
 *
 * @param transformation    the name of the transformation, e.g.,
 *                          <code>XMLCipher.TRIPLEDES</code>. If null the XMLCipher can only
 *                          be used for decrypt or unwrap operations where the encryption method
 *                          is defined in the <code>EncryptionMethod</code> element.
 * @param provider          the JCE provider that supplies the transformation,
 *                          if null use the default provider.
 * @param canon             the name of the c14n algorithm, if
 *                          <code>null</code> use standard serializer
 * @param digestMethod      An optional digestMethod to use.
 */
private XMLCipher(
    String transformation,
    String provider,
    String canonAlg,
    String digestMethod
) throws XMLEncryptionException {
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Constructing XMLCipher...");
    }

    factory = new Factory();

    algorithm = transformation;
    requestedJCEProvider = provider;
    digestAlg = digestMethod;

    // Create a canonicalizer - used when serializing DOM to octets
    // prior to encryption (and for the reverse)

    try {
        if (canonAlg == null) {
            // The default is to preserve the physical representation.
            this.canon = Canonicalizer.getInstance(Canonicalizer.ALGO_ID_C14N_PHYSICAL);
        } else {
            this.canon = Canonicalizer.getInstance(canonAlg);
        }
    } catch (InvalidCanonicalizerException ice) {
        throw new XMLEncryptionException("empty", ice);
    }

    if (serializer == null) {
        serializer = new DocumentSerializer();
    }
    serializer.setCanonicalizer(this.canon);

    if (transformation != null) {
        contextCipher = constructCipher(transformation, digestMethod);
    }
}
 

/**
 * Creates a new <code>XMLCipher</code>.
 *
 * @param transformation    the name of the transformation, e.g.,
 *                          <code>XMLCipher.TRIPLEDES</code>. If null the XMLCipher can only
 *                          be used for decrypt or unwrap operations where the encryption method
 *                          is defined in the <code>EncryptionMethod</code> element.
 * @param provider          the JCE provider that supplies the transformation,
 *                          if null use the default provider.
 * @param canon             the name of the c14n algorithm, if
 *                          <code>null</code> use standard serializer
 * @param digestMethod      An optional digestMethod to use.
 */
private XMLCipher(
    String transformation,
    String provider,
    String canonAlg,
    String digestMethod
) throws XMLEncryptionException {
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Constructing XMLCipher...");
    }

    factory = new Factory();

    algorithm = transformation;
    requestedJCEProvider = provider;
    digestAlg = digestMethod;

    // Create a canonicalizer - used when serializing DOM to octets
    // prior to encryption (and for the reverse)

    try {
        if (canonAlg == null) {
            // The default is to preserve the physical representation.
            this.canon = Canonicalizer.getInstance(Canonicalizer.ALGO_ID_C14N_PHYSICAL);
        } else {
            this.canon = Canonicalizer.getInstance(canonAlg);
        }
    } catch (InvalidCanonicalizerException ice) {
        throw new XMLEncryptionException("empty", ice);
    }

    if (serializer == null) {
        serializer = new DocumentSerializer();
    }
    serializer.setCanonicalizer(this.canon);

    if (transformation != null) {
        contextCipher = constructCipher(transformation, digestMethod);
    }
}
 

/**
 * Creates a new <code>XMLCipher</code>.
 *
 * @param transformation    the name of the transformation, e.g.,
 *                          <code>XMLCipher.TRIPLEDES</code>. If null the XMLCipher can only
 *                          be used for decrypt or unwrap operations where the encryption method
 *                          is defined in the <code>EncryptionMethod</code> element.
 * @param provider          the JCE provider that supplies the transformation,
 *                          if null use the default provider.
 * @param canon             the name of the c14n algorithm, if
 *                          <code>null</code> use standard serializer
 * @param digestMethod      An optional digestMethod to use.
 */
private XMLCipher(
    String transformation,
    String provider,
    String canonAlg,
    String digestMethod
) throws XMLEncryptionException {
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Constructing XMLCipher...");
    }

    factory = new Factory();

    algorithm = transformation;
    requestedJCEProvider = provider;
    digestAlg = digestMethod;

    // Create a canonicalizer - used when serializing DOM to octets
    // prior to encryption (and for the reverse)

    try {
        if (canonAlg == null) {
            // The default is to preserve the physical representation.
            this.canon = Canonicalizer.getInstance(Canonicalizer.ALGO_ID_C14N_PHYSICAL);
        } else {
            this.canon = Canonicalizer.getInstance(canonAlg);
        }
    } catch (InvalidCanonicalizerException ice) {
        throw new XMLEncryptionException("empty", ice);
    }

    if (serializer == null) {
        serializer = new DocumentSerializer();
    }
    serializer.setCanonicalizer(this.canon);

    if (transformation != null) {
        contextCipher = constructCipher(transformation, digestMethod);
    }
}
 

/**
 * Creates a new <code>XMLCipher</code>.
 *
 * @param transformation    the name of the transformation, e.g.,
 *                          <code>XMLCipher.TRIPLEDES</code>. If null the XMLCipher can only
 *                          be used for decrypt or unwrap operations where the encryption method
 *                          is defined in the <code>EncryptionMethod</code> element.
 * @param provider          the JCE provider that supplies the transformation,
 *                          if null use the default provider.
 * @param canon             the name of the c14n algorithm, if
 *                          <code>null</code> use standard serializer
 * @param digestMethod      An optional digestMethod to use.
 */
private XMLCipher(
    String transformation,
    String provider,
    String canonAlg,
    String digestMethod
) throws XMLEncryptionException {
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Constructing XMLCipher...");
    }

    factory = new Factory();

    algorithm = transformation;
    requestedJCEProvider = provider;
    digestAlg = digestMethod;

    // Create a canonicalizer - used when serializing DOM to octets
    // prior to encryption (and for the reverse)

    try {
        if (canonAlg == null) {
            // The default is to preserve the physical representation.
            this.canon = Canonicalizer.getInstance(Canonicalizer.ALGO_ID_C14N_PHYSICAL);
        } else {
            this.canon = Canonicalizer.getInstance(canonAlg);
        }
    } catch (InvalidCanonicalizerException ice) {
        throw new XMLEncryptionException("empty", ice);
    }

    if (serializer == null) {
        serializer = new DocumentSerializer();
    }
    serializer.setCanonicalizer(this.canon);

    if (transformation != null) {
        contextCipher = constructCipher(transformation, digestMethod);
    }
}
 

/** @inheritDoc */
public final String engineGetURI() {
    return Canonicalizer.ALGO_ID_C14N_EXCL_WITH_COMMENTS;
}
 

/** @inheritDoc */
public final String engineGetURI() {
    return Canonicalizer.ALGO_ID_C14N_EXCL_WITH_COMMENTS;
}
 

/** @inheritDoc */
public final String engineGetURI() {
    return Canonicalizer.ALGO_ID_C14N_EXCL_WITH_COMMENTS;
}
 

public void setCanonicalizer(Canonicalizer canon) {
    this.canon = canon;
}
 

public final String engineGetURI() {
    return Canonicalizer.ALGO_ID_C14N11_WITH_COMMENTS;
}
 

private byte[] getShaCanonizedValue(String Alg, Node xml) throws InvalidCanonicalizerException, NoSuchAlgorithmException, CanonicalizationException, ParserConfigurationException, IOException, SAXException {
	Init.init();
	Canonicalizer c14n = Canonicalizer.getInstance("http://www.w3.org/TR/2001/REC-xml-c14n-20010315");
	MessageDigest messageDigest = MessageDigest.getInstance(Alg);
	return messageDigest.digest(c14n.canonicalizeSubtree(xml));
}