/** * Computes and returns the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @return the computed one way hash value * @see #reset */ public byte[] digest() { return engineDigest(); }
/** * Computes and stores the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @param buf * the buffer to store the result * @param offset * the index of the first byte in {@code buf} to store * @param len * the number of bytes allocated for the digest * @return the number of bytes written to {@code buf} * @throws DigestException * if an error occurs * @throws IllegalArgumentException * if {@code offset} or {@code len} are not valid in respect to * {@code buf} * @see #reset() */ public int digest(byte[] buf, int offset, int len) throws DigestException { if (buf == null || // offset < 0 || len < 0 || // checks for negative values are commented out intentionally // see HARMONY-1148 for details (long) offset + (long) len > buf.length) { throw new IllegalArgumentException(); } return engineDigest(buf, offset, len); }
/** * Computes and returns the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @return the computed one way hash value * @see #reset */ public byte[] digest() { return engineDigest(); }
/** * Computes and returns the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @return the computed one way hash value * @see #reset */ public byte[] digest() { return engineDigest(); }
/** * Computes and returns the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @return the computed one way hash value * @see #reset */ public byte[] digest() { return engineDigest(); }
/** * Computes and returns the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @return the computed one way hash value * @see #reset */ public byte[] digest() { return engineDigest(); }
/** * Computes and returns the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @return the computed one way hash value * @see #reset */ public byte[] digest() { return engineDigest(); }
/** * Computes and returns the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @return the computed one way hash value * @see #reset */ public byte[] digest() { return engineDigest(); }
public int digest(byte[] buf, int offset, int len) throws DigestException { return engineDigest(buf, offset, len); }
public byte[] digest() { return engineDigest(); }
/** * Computes and stores the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @param buf * the buffer to store the result * @param offset * the index of the first byte in {@code buf} to store * @param len * the number of bytes allocated for the digest * @return the number of bytes written to {@code buf} * @throws DigestException * if an error occurs * @throws IllegalArgumentException * if {@code offset} or {@code len} are not valid in respect to * {@code buf} * @see #reset() */ public int digest(byte[] buf, int offset, int len) throws DigestException { if (buf == null || // offset < 0 || len < 0 || // checks for negative values are commented out intentionally // see HARMONY-1148 for details (long) offset + (long) len > buf.length) { throw new IllegalArgumentException(); } return engineDigest(buf, offset, len); }
/** * Computes and stores the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @param buf * the buffer to store the result * @param offset * the index of the first byte in {@code buf} to store * @param len * the number of bytes allocated for the digest * @return the number of bytes written to {@code buf} * @throws DigestException * if an error occurs * @throws IllegalArgumentException * if {@code offset} or {@code len} are not valid in respect to * {@code buf} * @see #reset() */ public int digest(byte[] buf, int offset, int len) throws DigestException { if (buf == null || // offset < 0 || len < 0 || // checks for negative values are commented out intentionally // see HARMONY-1148 for details (long) offset + (long) len > buf.length) { throw new IllegalArgumentException(); } return engineDigest(buf, offset, len); }
/** * Computes and stores the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @param buf * the buffer to store the result * @param offset * the index of the first byte in {@code buf} to store * @param len * the number of bytes allocated for the digest * @return the number of bytes written to {@code buf} * @throws DigestException * if an error occurs * @throws IllegalArgumentException * if {@code offset} or {@code len} are not valid in respect to * {@code buf} * @see #reset() */ public int digest(byte[] buf, int offset, int len) throws DigestException { if (buf == null || // offset < 0 || len < 0 || // checks for negative values are commented out intentionally // see HARMONY-1148 for details (long) offset + (long) len > buf.length) { throw new IllegalArgumentException(); } return engineDigest(buf, offset, len); }
/** * Computes and stores the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @param buf * the buffer to store the result * @param offset * the index of the first byte in {@code buf} to store * @param len * the number of bytes allocated for the digest * @return the number of bytes written to {@code buf} * @throws DigestException * if an error occurs * @throws IllegalArgumentException * if {@code offset} or {@code len} are not valid in respect to * {@code buf} * @see #reset() */ public int digest(byte[] buf, int offset, int len) throws DigestException { if (buf == null || // offset < 0 || len < 0 || // checks for negative values are commented out intentionally // see HARMONY-1148 for details (long) offset + (long) len > buf.length) { throw new IllegalArgumentException(); } return engineDigest(buf, offset, len); }
/** * Computes and stores the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @param buf * the buffer to store the result * @param offset * the index of the first byte in {@code buf} to store * @param len * the number of bytes allocated for the digest * @return the number of bytes written to {@code buf} * @throws DigestException * if an error occurs * @throws IllegalArgumentException * if {@code offset} or {@code len} are not valid in respect to * {@code buf} * @see #reset() */ public int digest(byte[] buf, int offset, int len) throws DigestException { if (buf == null || // offset < 0 || len < 0 || // checks for negative values are commented out intentionally // see HARMONY-1148 for details (long) offset + (long) len > buf.length) { throw new IllegalArgumentException(); } return engineDigest(buf, offset, len); }
/** * Computes and stores the final hash value for this {@link MessageDigest}. * After the digest is computed the receiver is reset. * * @param buf * the buffer to store the result * @param offset * the index of the first byte in {@code buf} to store * @param len * the number of bytes allocated for the digest * @return the number of bytes written to {@code buf} * @throws DigestException * if an error occurs * @throws IllegalArgumentException * if {@code offset} or {@code len} are not valid in respect to * {@code buf} * @see #reset() */ public int digest(byte[] buf, int offset, int len) throws DigestException { if (buf == null || // offset < 0 || len < 0 || // checks for negative values are commented out intentionally // see HARMONY-1148 for details (long) offset + (long) len > buf.length) { throw new IllegalArgumentException(); } return engineDigest(buf, offset, len); }
public byte[] digest(byte[] input) { engineUpdate(input, 0, input.length); return engineDigest(); }