jdk-sandbox: comparison jdk/src/windows/classes/sun/security/mscapi/RSASignature.java

equal deleted inserted replaced

-:a371830a963b
+:8417d0e74ac5
 *
 * Objects should be instantiated by calling Signature.getInstance() using the
 * following algorithm names:
 *
 *  . "SHA1withRSA"
+*  . "SHA256withRSA"
+*  . "SHA384withRSA"
+*  . "SHA512withRSA"
 *  . "MD5withRSA"
 *  . "MD2withRSA"
 *
 * Note: RSA keys must be at least 512 bits long
 *
 abstract class RSASignature extends java.security.SignatureSpi
 {
 // message digest implementation we use
 private final MessageDigest messageDigest;
-// flag indicating whether the digest is reset
+// message digest name
+private final String messageDigestAlgorithm;
+// flag indicating whether the digest has been reset
 private boolean needsReset;
 // the signing key
 private Key privateKey = null;
 // the verification key
 private Key publicKey = null;
+/**
+* Constructs a new RSASignature. Used by subclasses.
+*/
 RSASignature(String digestName) {
 try {
 messageDigest = MessageDigest.getInstance(digestName);
+// Get the digest's canonical name
+messageDigestAlgorithm = messageDigest.getAlgorithm();
 } catch (NoSuchAlgorithmException e) {
 throw new ProviderException(e);
 }
 public SHA1() {
 super("SHA1");
 }
 }
+public static final class SHA256 extends RSASignature {
+public SHA256() {
+super("SHA-256");
+}
+}
+public static final class SHA384 extends RSASignature {
+public SHA384() {
+super("SHA-384");
+}
+}
+public static final class SHA512 extends RSASignature {
+public SHA512() {
+super("SHA-512");
+}
+}
 public static final class MD5 extends RSASignature {
 public MD5() {
 super("MD5");
 }
 }
 public MD2() {
 super("MD2");
 }
 }
-/**
+// initialize for signing. See JCA doc
-* Initializes this signature object with the specified
-* public key for verification operations.
-*
-* @param publicKey the public key of the identity whose signature is
-* going to be verified.
-*
-* @exception InvalidKeyException if the key is improperly
-* encoded, parameters are missing, and so on.
-*/
 protected void engineInitVerify(PublicKey key)
 throws InvalidKeyException
 {
 // This signature accepts only RSAPublicKey
 if ((key instanceof java.security.interfaces.RSAPublicKey) == false) {
 } else {
 publicKey = (sun.security.mscapi.RSAPublicKey) key;
 }
-if (needsReset) {
+this.privateKey = null;
-messageDigest.reset();
+resetDigest();
-needsReset = false;
+}
-}
-}
+// initialize for signing. See JCA doc
+protected void engineInitSign(PrivateKey key) throws InvalidKeyException
-/**
-* Initializes this signature object with the specified
-* private key for signing operations.
-*
-* @param privateKey the private key of the identity whose signature
-* will be generated.
-*
-* @exception InvalidKeyException if the key is improperly
-* encoded, parameters are missing, and so on.
-*/
-protected void engineInitSign(PrivateKey key)
-throws InvalidKeyException
 {
 // This signature accepts only RSAPrivateKey
 if ((key instanceof sun.security.mscapi.RSAPrivateKey) == false) {
 throw new InvalidKeyException("Key type not supported");
 }
 // the sizes are ok.  Round up to nearest byte.
 RSAKeyFactory.checkKeyLengths(((privateKey.bitLength() + 7) & ~7),
 null, RSAKeyPairGenerator.KEY_SIZE_MIN,
 RSAKeyPairGenerator.KEY_SIZE_MAX);
+this.publicKey = null;
+resetDigest();
+}
+/**
+* Resets the message digest if needed.
+*/
+private void resetDigest() {
 if (needsReset) {
 messageDigest.reset();
 needsReset = false;
 }
+}
+private byte[] getDigestValue() {
+needsReset = false;
+return messageDigest.digest();
 }
 /**
 * Updates the data to be signed or verified
 * using the specified byte.
 * initialized properly or if this signature algorithm is unable to
 * process the input data provided.
 */
 protected byte[] engineSign() throws SignatureException {
-byte[] hash = messageDigest.digest();
+byte[] hash = getDigestValue();
-needsReset = false;
 // Sign hash using MS Crypto APIs
 byte[] result = signHash(hash, hash.length,
-messageDigest.getAlgorithm(), privateKey.getHCryptProvider(),
+messageDigestAlgorithm, privateKey.getHCryptProvider(),
 privateKey.getHCryptKey());
 // Convert signature array from little endian to big endian
 return convertEndianArray(result);
 }
 * process the input data provided, etc.
 */
 protected boolean engineVerify(byte[] sigBytes)
 throws SignatureException
 {
-byte[] hash = messageDigest.digest();
+byte[] hash = getDigestValue();
-needsReset = false;
 return verifySignedHash(hash, hash.length,
-messageDigest.getAlgorithm(), convertEndianArray(sigBytes),
+messageDigestAlgorithm, convertEndianArray(sigBytes),
 sigBytes.length, publicKey.getHCryptProvider(),
 publicKey.getHCryptKey());
 }
 /**

changeset 9524	8417d0e74ac5
parent 9508	310b4f6c8e61
child 9533	13cc5e8eb9f1