protected MessageDigest(String algorithm) 
{
        this.algorithm = algorithm;
}

Creates a message digest with the specified algorithm name.

Parameters:

algorithm - the standard name of the digest algorithm. See the MessageDigest section in the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard algorithm names.

 public Object clone() throws CloneNotSupportedException 
{
        if (this instanceof Cloneable) {
            return super.clone();
        } else {
            throw new CloneNotSupportedException();
        }
}

Returns a clone if the implementation is cloneable.

 public byte[] digest() 
{
        /* Resetting is the responsibility of implementors. */
        byte[] result = engineDigest();
        state = INITIAL;
        return result;
}

Completes the hash computation by performing final operations such as padding. The digest is reset after this call is made.

 public byte[] digest(byte[] input) 
{
        update(input);
        return digest();
}

Performs a final update on the digest using the specified array of bytes, then completes the digest computation. That is, this method first calls update(input) , passing the input array to the update method, then calls digest() .

 public int digest(byte[] buf,
    int offset,
    int len) throws DigestException 
{
        if (buf == null) {
            throw new IllegalArgumentException("No output buffer given");
        }
        if (buf.length - offset <  len) {
            throw new IllegalArgumentException
                ("Output buffer too small for specified offset and length");
        }
        int numBytes = engineDigest(buf, offset, len);
        state = INITIAL;
        return numBytes;
}

Completes the hash computation by performing final operations such as padding. The digest is reset after this call is made.

 public final String getAlgorithm() 
{
        return this.algorithm;
}

Returns a string that identifies the algorithm, independent of implementation details. The name should be a standard Java Security name (such as "SHA", "MD5", and so on). See the MessageDigest section in the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard algorithm names.

 public final int getDigestLength() 
{
        int digestLen = engineGetDigestLength();
        if (digestLen == 0) {
            try {
                MessageDigest md = (MessageDigest)clone();
                byte[] digest = md.digest();
                return digest.length;
            } catch (CloneNotSupportedException e) {
                return digestLen;
            }
        }
        return digestLen;
}

Returns the length of the digest in bytes, or 0 if this operation is not supported by the provider and the implementation is not cloneable.

 public static MessageDigest getInstance(String algorithm) throws NoSuchAlgorithmException 
{
        try {
            Object[] objs = Security.getImpl(algorithm, "MessageDigest",
                                             (String)null);
            if (objs[0] instanceof MessageDigest) {
                MessageDigest md = (MessageDigest)objs[0];
                md.provider = (Provider)objs[1];
                return md;
            } else {
                MessageDigest delegate =
                    new Delegate((MessageDigestSpi)objs[0], algorithm);
                delegate.provider = (Provider)objs[1];
                return delegate;
            }
        } catch(NoSuchProviderException e) {
            throw new NoSuchAlgorithmException(algorithm + " not found");
        }
}

Returns a MessageDigest object that implements the specified digest algorithm.

This method traverses the list of registered security Providers, starting with the most preferred Provider. A new MessageDigest object encapsulating the MessageDigestSpi implementation from the first Provider that supports the specified algorithm is returned.

Note that the list of registered providers may be retrieved via the Security.getProviders() method.

 public static MessageDigest getInstance(String algorithm,
    String provider) throws NoSuchAlgorithmException, NoSuchProviderException 
{
        if (provider == null || provider.length() == 0)
            throw new IllegalArgumentException("missing provider");
        Object[] objs = Security.getImpl(algorithm, "MessageDigest", provider);
        if (objs[0] instanceof MessageDigest) {
            MessageDigest md = (MessageDigest)objs[0];
            md.provider = (Provider)objs[1];
            return md;
        } else {
            MessageDigest delegate =
                new Delegate((MessageDigestSpi)objs[0], algorithm);
            delegate.provider = (Provider)objs[1];
            return delegate;
        }
}

Returns a MessageDigest object that implements the specified digest algorithm.

A new MessageDigest object encapsulating the MessageDigestSpi implementation from the specified provider is returned. The specified provider must be registered in the security provider list.

Note that the list of registered providers may be retrieved via the Security.getProviders() method.

 public static MessageDigest getInstance(String algorithm,
    Provider provider) throws NoSuchAlgorithmException 
{
        if (provider == null)
            throw new IllegalArgumentException("missing provider");
        Object[] objs = Security.getImpl(algorithm, "MessageDigest", provider);
        if (objs[0] instanceof MessageDigest) {
            MessageDigest md = (MessageDigest)objs[0];
            md.provider = (Provider)objs[1];
            return md;
        } else {
            MessageDigest delegate =
                new Delegate((MessageDigestSpi)objs[0], algorithm);
            delegate.provider = (Provider)objs[1];
            return delegate;
        }
}

Returns a MessageDigest object that implements the specified digest algorithm.

A new MessageDigest object encapsulating the MessageDigestSpi implementation from the specified Provider object is returned. Note that the specified Provider object does not have to be registered in the provider list.

 public final Provider getProvider() 
{
        return this.provider;
}

Returns the provider of this message digest object.

 public static boolean isEqual(byte[] digesta,
    byte[] digestb) 
{
        if (digesta.length != digestb.length) {
            return false;
        }
        int result = 0;
        // time-constant comparison
        for (int i = 0; i <  digesta.length; i++) {
            result |= digesta[i] ^ digestb[i];
        }
        return result == 0;
}

Compares two digests for equality. Does a simple byte compare.

 public  void reset() 
{
        engineReset();
        state = INITIAL;
}

Resets the digest for further use.

 public String toString() 
{
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream p = new PrintStream(baos);
        p.print(algorithm+" Message Digest from "+provider.getName()+", ");
        switch (state) {
        case INITIAL:
            p.print("< initialized >");
            break;
        case IN_PROGRESS:
            p.print("< in progress >");
            break;
        }
        p.println();
        return (baos.toString());
}

Returns a string representation of this message digest object.

 public  void update(byte input) 
{
        engineUpdate(input);
        state = IN_PROGRESS;
}

Updates the digest using the specified byte.

 public  void update(byte[] input) 
{
        engineUpdate(input, 0, input.length);
        state = IN_PROGRESS;
}

Updates the digest using the specified array of bytes.

 public final  void update(ByteBuffer input) 
{
        if (input == null) {
            throw new NullPointerException();
        }
        engineUpdate(input);
        state = IN_PROGRESS;
}

Update the digest using the specified ByteBuffer. The digest is updated using the input.remaining() bytes starting at input.position(). Upon return, the buffer's position will be equal to its limit; its limit will not have changed.

 public  void update(byte[] input,
    int offset,
    int len) 
{
        if (input == null) {
            throw new IllegalArgumentException("No input buffer given");
        }
        if (input.length - offset <  len) {
            throw new IllegalArgumentException("Input buffer too short");
        }
        engineUpdate(input, offset, len);
        state = IN_PROGRESS;
}

Updates the digest using the specified array of bytes, starting at the specified offset.