import com.sun.org.apache.xml.internal.security.utils.UnsyncBufferedOutputStream; //导入依赖的package包/类
public void canonicalize(XMLCryptoContext context, ByteArrayOutputStream bos)
    throws XMLSignatureException {
    if (context == null) {
        throw new NullPointerException("context cannot be null");
    }

    OutputStream os = new UnsyncBufferedOutputStream(bos);
    try {
        os.close();
    } catch (IOException e) {
        if (log.isLoggable(java.util.logging.Level.FINE)) {
            log.log(java.util.logging.Level.FINE, e.getMessage(), e);
        }
        // Impossible
    }

    DOMSubTreeData subTree = new DOMSubTreeData(localSiElem, true);

    try {
        ((DOMCanonicalizationMethod)
            canonicalizationMethod).canonicalize(subTree, context, bos);
    } catch (TransformException te) {
        throw new XMLSignatureException(te);
    }

    byte[] signedInfoBytes = bos.toByteArray();

    // this whole block should only be done if logging is enabled
    if (log.isLoggable(java.util.logging.Level.FINE)) {
        log.log(java.util.logging.Level.FINE, "Canonicalized SignedInfo:");
        StringBuilder sb = new StringBuilder(signedInfoBytes.length);
        for (int i = 0; i < signedInfoBytes.length; i++) {
            sb.append((char)signedInfoBytes[i]);
        }
        log.log(java.util.logging.Level.FINE, sb.toString());
        log.log(java.util.logging.Level.FINE, "Data to be signed/verified:" + Base64.encode(signedInfoBytes));
    }

    this.canonData = new ByteArrayInputStream(signedInfoBytes);
}
 

import com.sun.org.apache.xml.internal.security.utils.UnsyncBufferedOutputStream; //导入依赖的package包/类
public void canonicalize(XMLCryptoContext context,ByteArrayOutputStream bos)
    throws XMLSignatureException {

    if (context == null) {
        throw new NullPointerException("context cannot be null");
    }

    OutputStream os = new UnsyncBufferedOutputStream(bos);
    try {
        os.close();
    } catch (IOException e) {
        // Impossible
    }

    DOMSubTreeData subTree = new DOMSubTreeData(localSiElem, true);

    try {
        Data data = ((DOMCanonicalizationMethod)
            canonicalizationMethod).canonicalize(subTree, context, os);
    } catch (TransformException te) {
        throw new XMLSignatureException(te);
    }

    byte[] signedInfoBytes = bos.toByteArray();

    // this whole block should only be done if logging is enabled
    if (log.isLoggable(Level.FINE)) {
        InputStreamReader isr = new InputStreamReader
            (new ByteArrayInputStream(signedInfoBytes));
        char[] siBytes = new char[signedInfoBytes.length];
        try {
            isr.read(siBytes);
            log.log(Level.FINE, "Canonicalized SignedInfo:\n"
                + new String(siBytes));
        } catch (IOException ioex) {
            log.log(Level.FINE, "IOException reading SignedInfo bytes");
        }
        log.log(Level.FINE, "Data to be signed/verified:"
            + Base64.encode(signedInfoBytes));
    }

    this.canonData = new ByteArrayInputStream(signedInfoBytes);
}
 

import com.sun.org.apache.xml.internal.security.utils.UnsyncBufferedOutputStream; //导入依赖的package包/类
/**
 * Verifies if the signature is valid by redigesting all References,
 * comparing those against the stored DigestValues and then checking to see
 * if the Signatures match on the SignedInfo.
 *
 * @param pk {@link java.security.PublicKey} part of the keypair or {@link javax.crypto.SecretKey} that was used to sign
 * @return true if the signature is valid, false otherwise
 * @throws XMLSignatureException
 */
public boolean checkSignatureValue(Key pk) throws XMLSignatureException {

   //COMMENT: pk suggests it can only be a public key?
   //check to see if the key is not null
   if (pk == null) {
      Object exArgs[] = { "Didn't get a key" };

      throw new XMLSignatureException("empty", exArgs);
   }
   // all references inside the signedinfo need to be dereferenced and
   // digested again to see if the outcome matches the stored value in the
   // SignedInfo.
   // If _followManifestsDuringValidation is true it will do the same for
   // References inside a Manifest.
   try {
      SignedInfo si=this.getSignedInfo();
      //create a SignatureAlgorithms from the SignatureMethod inside
      //SignedInfo. This is used to validate the signature.
      SignatureAlgorithm sa =si.getSignatureAlgorithm();
      if (log.isLoggable(java.util.logging.Level.FINE)) {
             log.log(java.util.logging.Level.FINE, "SignatureMethodURI = " + sa.getAlgorithmURI());
             log.log(java.util.logging.Level.FINE, "jceSigAlgorithm    = " + sa.getJCEAlgorithmString());
             log.log(java.util.logging.Level.FINE, "jceSigProvider     = " + sa.getJCEProviderName());
             log.log(java.util.logging.Level.FINE, "PublicKey = " + pk);
      }
      sa.initVerify(pk);

      // Get the canonicalized (normalized) SignedInfo
      SignerOutputStream so=new SignerOutputStream(sa);
      OutputStream bos=new UnsyncBufferedOutputStream(so);
      si.signInOctectStream(bos);
      try {
             bos.close();
      } catch (IOException e) {
             //Imposible
      }

      //retrieve the byte[] from the stored signature
      byte sigBytes[] = this.getSignatureValue();

      //Have SignatureAlgorithm sign the input bytes and compare them to the
      //bytes that were stored in the signature.
      if (!sa.verify(sigBytes)) {
         log.log(java.util.logging.Level.WARNING, "Signature verification failed.");
         return false;
      }

      return si.verify(this._followManifestsDuringValidation);
   } catch (XMLSecurityException ex) {
      throw new XMLSignatureException("empty", ex);
   }
}