    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017
    018package org.apache.commons.codec.digest;
    019
    020import java.io.BufferedInputStream;
    021import java.io.File;
    022import java.io.FileInputStream;
    023import java.io.IOException;
    024import java.io.InputStream;
    025import java.io.RandomAccessFile;
    026import java.nio.ByteBuffer;
    027import java.nio.channels.FileChannel;
    028import java.nio.file.Files;
    029import java.nio.file.OpenOption;
    030import java.nio.file.Path;
    031import java.security.MessageDigest;
    032import java.security.NoSuchAlgorithmException;
    033
    034import org.apache.commons.codec.binary.Hex;
    035import org.apache.commons.codec.binary.StringUtils;
    036
    037/**
    038 * Operations to simplify common {@link java.security.MessageDigest} tasks. This class is immutable and thread-safe. However the MessageDigest instances it
    039 * creates generally won't be.
    040 * <p>
    041 * The {@link MessageDigestAlgorithms} class provides constants for standard digest algorithms that can be used with the {@link #getDigest(String)} method and
    042 * other methods that require the Digest algorithm name.
    043 * </p>
    044 * <p>
    045 * Note: the class has shorthand methods for all the algorithms present as standard in Java 6. This approach requires lots of methods for each algorithm, and
    046 * quickly becomes unwieldy. The following code works with all algorithms:
    047 * </p>
    048 *
    049 * <pre>
    050 * import static org.apache.commons.codec.digest.MessageDigestAlgorithms.SHA_224;
    051 * ...
    052 * byte [] digest = new DigestUtils(SHA_224).digest(dataToDigest);
    053 * String hdigest = new DigestUtils(SHA_224).digestAsHex(new File("pom.xml"));
    054 * </pre>
    055 *
    056 * @see MessageDigestAlgorithms
    057 */
    058public class DigestUtils {
    059
    060    /**
    061     * Package-private for tests.
    062     */
    063    static final int BUFFER_SIZE = 1024;
    064
    065    /**
    066     * Reads through a byte array and returns the digest for the data. Provided for symmetry with other methods.
    067     *
    068     * @param messageDigest The MessageDigest to use (e.g. MD5)
    069     * @param data          Data to digest
    070     * @return the digest
    071     * @since 1.11
    072     */
    073    public static byte[] digest(final MessageDigest messageDigest, final byte[] data) {
    074        return messageDigest.digest(data);
    075    }
    076
    077    /**
    078     * Reads through a ByteBuffer and returns the digest for the data
    079     *
    080     * @param messageDigest The MessageDigest to use (e.g. MD5)
    081     * @param data          Data to digest
    082     * @return the digest
    083     *
    084     * @since 1.11
    085     */
    086    public static byte[] digest(final MessageDigest messageDigest, final ByteBuffer data) {
    087        messageDigest.update(data);
    088        return messageDigest.digest();
    089    }
    090
    091    /**
    092     * Reads through a File and returns the digest for the data
    093     *
    094     * @param messageDigest The MessageDigest to use (e.g. MD5)
    095     * @param data          Data to digest
    096     * @return the digest
    097     * @throws IOException On error reading from the stream
    098     * @since 1.11
    099     */
    100    public static byte[] digest(final MessageDigest messageDigest, final File data) throws IOException {
    101        return updateDigest(messageDigest, data).digest();
    102    }
    103
    104    /**
    105     * Reads through an InputStream and returns the digest for the data
    106     *
    107     * @param messageDigest The MessageDigest to use (e.g. MD5)
    108     * @param data          Data to digest
    109     * @return the digest
    110     * @throws IOException On error reading from the stream
    111     * @since 1.11 (was private)
    112     */
    113    public static byte[] digest(final MessageDigest messageDigest, final InputStream data) throws IOException {
    114        return updateDigest(messageDigest, data).digest();
    115    }
    116
    117    /**
    118     * Reads through a File and returns the digest for the data
    119     *
    120     * @param messageDigest The MessageDigest to use (e.g. MD5)
    121     * @param data          Data to digest
    122     * @param options       options How to open the file
    123     * @return the digest
    124     * @throws IOException On error reading from the stream
    125     * @since 1.14
    126     */
    127    public static byte[] digest(final MessageDigest messageDigest, final Path data, final OpenOption... options) throws IOException {
    128        return updateDigest(messageDigest, data, options).digest();
    129    }
    130
    131    /**
    132     * Reads through a RandomAccessFile using non-blocking-io (NIO) and returns the digest for the data
    133     *
    134     * @param messageDigest The MessageDigest to use (e.g. MD5)
    135     * @param data          Data to digest
    136     * @return the digest
    137     * @throws IOException On error reading from the stream
    138     * @since 1.14
    139     */
    140    public static byte[] digest(final MessageDigest messageDigest, final RandomAccessFile data) throws IOException {
    141        return updateDigest(messageDigest, data).digest();
    142    }
    143
    144    /**
    145     * Gets a {@code MessageDigest} for the given {@code algorithm}.
    146     *
    147     * @param algorithm the name of the algorithm requested. See
    148     *                  <a href="https://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA" >Appendix A in the Java
    149     *                  Cryptography Architecture Reference Guide</a> for information about standard algorithm names.
    150     * @return A digest instance.
    151     * @see MessageDigest#getInstance(String)
    152     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught.
    153     */
    154    public static MessageDigest getDigest(final String algorithm) {
    155        try {
    156            return getMessageDigest(algorithm);
    157        } catch (final NoSuchAlgorithmException e) {
    158            throw new IllegalArgumentException(e);
    159        }
    160    }
    161
    162    /**
    163     * Gets a {@code MessageDigest} for the given {@code algorithm} or a default if there is a problem getting the algorithm.
    164     *
    165     * @param algorithm            the name of the algorithm requested. See
    166     *                             <a href="https://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA" > Appendix A in the Java
    167     *                             Cryptography Architecture Reference Guide</a> for information about standard algorithm names.
    168     * @param defaultMessageDigest The default MessageDigest.
    169     * @return A digest instance.
    170     * @see MessageDigest#getInstance(String)
    171     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught.
    172     * @since 1.11
    173     */
    174    public static MessageDigest getDigest(final String algorithm, final MessageDigest defaultMessageDigest) {
    175        try {
    176            return getMessageDigest(algorithm);
    177        } catch (final Exception e) {
    178            return defaultMessageDigest;
    179        }
    180    }
    181
    182    /**
    183     * Gets an MD2 MessageDigest.
    184     *
    185     * @return An MD2 digest instance.
    186     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should never happen because MD2 is a built-in algorithm
    187     * @see MessageDigestAlgorithms#MD2
    188     * @since 1.7
    189     */
    190    public static MessageDigest getMd2Digest() {
    191        return getDigest(MessageDigestAlgorithms.MD2);
    192    }
    193
    194    /**
    195     * Gets an MD5 MessageDigest.
    196     *
    197     * @return An MD5 digest instance.
    198     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should never happen because MD5 is a built-in algorithm
    199     * @see MessageDigestAlgorithms#MD5
    200     */
    201    public static MessageDigest getMd5Digest() {
    202        return getDigest(MessageDigestAlgorithms.MD5);
    203    }
    204
    205    /**
    206     * Gets a {@code MessageDigest} for the given {@code algorithm}.
    207     *
    208     * @param algorithm the name of the algorithm requested. See
    209     *                  <a href="https://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA" > Appendix A in the Java
    210     *                  Cryptography Architecture Reference Guide</a> for information about standard algorithm names.
    211     * @return A digest instance.
    212     * @see MessageDigest#getInstance(String)
    213     * @throws NoSuchAlgorithmException if no Provider supports a MessageDigestSpi implementation for the specified algorithm.
    214     */
    215    private static MessageDigest getMessageDigest(final String algorithm) throws NoSuchAlgorithmException {
    216        return MessageDigest.getInstance(algorithm);
    217    }
    218
    219    /**
    220     * Gets an SHA-1 digest.
    221     *
    222     * @return An SHA-1 digest instance.
    223     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should never happen because SHA-1 is a built-in algorithm
    224     * @see MessageDigestAlgorithms#SHA_1
    225     * @since 1.7
    226     */
    227    public static MessageDigest getSha1Digest() {
    228        return getDigest(MessageDigestAlgorithms.SHA_1);
    229    }
    230
    231    /**
    232     * Gets an SHA-256 digest.
    233     *
    234     * @return An SHA-256 digest instance.
    235     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should never happen because SHA-256 is a built-in algorithm
    236     * @see MessageDigestAlgorithms#SHA_256
    237     */
    238    public static MessageDigest getSha256Digest() {
    239        return getDigest(MessageDigestAlgorithms.SHA_256);
    240    }
    241
    242    /**
    243     * Gets an SHA3-224 digest.
    244     *
    245     * @return An SHA3-224 digest instance.
    246     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should not happen on Oracle Java 9 and greater.
    247     * @see MessageDigestAlgorithms#SHA3_224
    248     * @since 1.12
    249     */
    250    public static MessageDigest getSha3_224Digest() {
    251        return getDigest(MessageDigestAlgorithms.SHA3_224);
    252    }
    253
    254    /**
    255     * Returns an SHA3-256 digest.
    256     *
    257     * @return An SHA3-256 digest instance.
    258     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should not happen on Oracle Java 9 and greater.
    259     * @see MessageDigestAlgorithms#SHA3_256
    260     * @since 1.12
    261     */
    262    public static MessageDigest getSha3_256Digest() {
    263        return getDigest(MessageDigestAlgorithms.SHA3_256);
    264    }
    265
    266    /**
    267     * Gets an SHA3-384 digest.
    268     *
    269     * @return An SHA3-384 digest instance.
    270     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should not happen on Oracle Java 9 and greater.
    271     * @see MessageDigestAlgorithms#SHA3_384
    272     * @since 1.12
    273     */
    274    public static MessageDigest getSha3_384Digest() {
    275        return getDigest(MessageDigestAlgorithms.SHA3_384);
    276    }
    277
    278    /**
    279     * Gets an SHA3-512 digest.
    280     *
    281     * @return An SHA3-512 digest instance.
    282     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should not happen on Oracle Java 9 and greater.
    283     * @see MessageDigestAlgorithms#SHA3_512
    284     * @since 1.12
    285     */
    286    public static MessageDigest getSha3_512Digest() {
    287        return getDigest(MessageDigestAlgorithms.SHA3_512);
    288    }
    289
    290    /**
    291     * Gets an SHA-384 digest.
    292     *
    293     * @return An SHA-384 digest instance.
    294     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should never happen because SHA-384 is a built-in algorithm
    295     * @see MessageDigestAlgorithms#SHA_384
    296     */
    297    public static MessageDigest getSha384Digest() {
    298        return getDigest(MessageDigestAlgorithms.SHA_384);
    299    }
    300
    301    /**
    302     * Gets an SHA-512/224 digest.
    303     *
    304     * @return An SHA-512/224 digest instance.
    305     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught.
    306     * @see MessageDigestAlgorithms#SHA_512_224
    307     */
    308    public static MessageDigest getSha512_224Digest() {
    309        return getDigest(MessageDigestAlgorithms.SHA_512_224);
    310    }
    311
    312    /**
    313     * Gets an SHA-512/256 digest.
    314     *
    315     * @return An SHA-512/256 digest instance.
    316     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught.
    317     * @see MessageDigestAlgorithms#SHA_512_224
    318     */
    319    public static MessageDigest getSha512_256Digest() {
    320        return getDigest(MessageDigestAlgorithms.SHA_512_256);
    321    }
    322
    323    /**
    324     * Gets an SHA-512 digest.
    325     *
    326     * @return An SHA-512 digest instance.
    327     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught, which should never happen because SHA-512 is a built-in algorithm
    328     * @see MessageDigestAlgorithms#SHA_512
    329     */
    330    public static MessageDigest getSha512Digest() {
    331        return getDigest(MessageDigestAlgorithms.SHA_512);
    332    }
    333
    334    /**
    335     * Gets an SHA-1 digest.
    336     *
    337     * @return An SHA-1 digest instance.
    338     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught
    339     * @deprecated (1.11) Use {@link #getSha1Digest()}
    340     */
    341    @Deprecated
    342    public static MessageDigest getShaDigest() {
    343        return getSha1Digest();
    344    }
    345
    346    /**
    347     * Test whether the algorithm is supported.
    348     *
    349     * @param messageDigestAlgorithm the algorithm name
    350     * @return {@code true} if the algorithm can be found
    351     * @since 1.11
    352     */
    353    public static boolean isAvailable(final String messageDigestAlgorithm) {
    354        return getDigest(messageDigestAlgorithm, null) != null;
    355    }
    356
    357    /**
    358     * Calculates the MD2 digest and returns the value as a 16 element {@code byte[]}.
    359     *
    360     * @param data Data to digest
    361     * @return MD2 digest
    362     * @since 1.7
    363     */
    364    public static byte[] md2(final byte[] data) {
    365        return getMd2Digest().digest(data);
    366    }
    367
    368    /**
    369     * Calculates the MD2 digest and returns the value as a 16 element {@code byte[]}.
    370     *
    371     * @param data Data to digest
    372     * @return MD2 digest
    373     * @throws IOException On error reading from the stream
    374     * @since 1.7
    375     */
    376    public static byte[] md2(final InputStream data) throws IOException {
    377        return digest(getMd2Digest(), data);
    378    }
    379
    380    /**
    381     * Calculates the MD2 digest and returns the value as a 16 element {@code byte[]}.
    382     *
    383     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    384     * @return MD2 digest
    385     * @since 1.7
    386     */
    387    public static byte[] md2(final String data) {
    388        return md2(StringUtils.getBytesUtf8(data));
    389    }
    390
    391    /**
    392     * Calculates the MD2 digest and returns the value as a 32 character hexadecimal string.
    393     *
    394     * @param data Data to digest
    395     * @return MD2 digest as a hexadecimal string
    396     * @since 1.7
    397     */
    398    public static String md2Hex(final byte[] data) {
    399        return Hex.encodeHexString(md2(data));
    400    }
    401
    402    /**
    403     * Calculates the MD2 digest and returns the value as a 32 character hexadecimal string.
    404     *
    405     * @param data Data to digest
    406     * @return MD2 digest as a hexadecimal string
    407     * @throws IOException On error reading from the stream
    408     * @since 1.7
    409     */
    410    public static String md2Hex(final InputStream data) throws IOException {
    411        return Hex.encodeHexString(md2(data));
    412    }
    413
    414    /**
    415     * Calculates the MD2 digest and returns the value as a 32 character hexadecimal string.
    416     *
    417     * @param data Data to digest
    418     * @return MD2 digest as a hexadecimal string
    419     * @since 1.7
    420     */
    421    public static String md2Hex(final String data) {
    422        return Hex.encodeHexString(md2(data));
    423    }
    424
    425    /**
    426     * Calculates the MD5 digest and returns the value as a 16 element {@code byte[]}.
    427     *
    428     * @param data Data to digest
    429     * @return MD5 digest
    430     */
    431    public static byte[] md5(final byte[] data) {
    432        return getMd5Digest().digest(data);
    433    }
    434
    435    /**
    436     * Calculates the MD5 digest and returns the value as a 16 element {@code byte[]}.
    437     *
    438     * @param data Data to digest
    439     * @return MD5 digest
    440     * @throws IOException On error reading from the stream
    441     * @since 1.4
    442     */
    443    public static byte[] md5(final InputStream data) throws IOException {
    444        return digest(getMd5Digest(), data);
    445    }
    446
    447    /**
    448     * Calculates the MD5 digest and returns the value as a 16 element {@code byte[]}.
    449     *
    450     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    451     * @return MD5 digest
    452     */
    453    public static byte[] md5(final String data) {
    454        return md5(StringUtils.getBytesUtf8(data));
    455    }
    456
    457    /**
    458     * Calculates the MD5 digest and returns the value as a 32 character hexadecimal string.
    459     *
    460     * @param data Data to digest
    461     * @return MD5 digest as a hexadecimal string
    462     */
    463    public static String md5Hex(final byte[] data) {
    464        return Hex.encodeHexString(md5(data));
    465    }
    466
    467    /**
    468     * Calculates the MD5 digest and returns the value as a 32 character hexadecimal string.
    469     *
    470     * @param data Data to digest
    471     * @return MD5 digest as a hexadecimal string
    472     * @throws IOException On error reading from the stream
    473     * @since 1.4
    474     */
    475    public static String md5Hex(final InputStream data) throws IOException {
    476        return Hex.encodeHexString(md5(data));
    477    }
    478
    479    /**
    480     * Calculates the MD5 digest and returns the value as a 32 character hexadecimal string.
    481     *
    482     * @param data Data to digest
    483     * @return MD5 digest as a hexadecimal string
    484     */
    485    public static String md5Hex(final String data) {
    486        return Hex.encodeHexString(md5(data));
    487    }
    488
    489    /**
    490     * Calculates the SHA-1 digest and returns the value as a {@code byte[]}.
    491     *
    492     * @param data Data to digest
    493     * @return SHA-1 digest
    494     * @deprecated (1.11) Use {@link #sha1(byte[])}
    495     */
    496    @Deprecated
    497    public static byte[] sha(final byte[] data) {
    498        return sha1(data);
    499    }
    500
    501    /**
    502     * Calculates the SHA-1 digest and returns the value as a {@code byte[]}.
    503     *
    504     * @param data Data to digest
    505     * @return SHA-1 digest
    506     * @throws IOException On error reading from the stream
    507     * @since 1.4
    508     * @deprecated (1.11) Use {@link #sha1(InputStream)}
    509     */
    510    @Deprecated
    511    public static byte[] sha(final InputStream data) throws IOException {
    512        return sha1(data);
    513    }
    514
    515    /**
    516     * Calculates the SHA-1 digest and returns the value as a {@code byte[]}.
    517     *
    518     * @param data Data to digest
    519     * @return SHA-1 digest
    520     * @deprecated (1.11) Use {@link #sha1(String)}
    521     */
    522    @Deprecated
    523    public static byte[] sha(final String data) {
    524        return sha1(data);
    525    }
    526
    527    /**
    528     * Calculates the SHA-1 digest and returns the value as a {@code byte[]}.
    529     *
    530     * @param data Data to digest
    531     * @return SHA-1 digest
    532     * @since 1.7
    533     */
    534    public static byte[] sha1(final byte[] data) {
    535        return getSha1Digest().digest(data);
    536    }
    537
    538    /**
    539     * Calculates the SHA-1 digest and returns the value as a {@code byte[]}.
    540     *
    541     * @param data Data to digest
    542     * @return SHA-1 digest
    543     * @throws IOException On error reading from the stream
    544     * @since 1.7
    545     */
    546    public static byte[] sha1(final InputStream data) throws IOException {
    547        return digest(getSha1Digest(), data);
    548    }
    549
    550    /**
    551     * Calculates the SHA-1 digest and returns the value as a {@code byte[]}.
    552     *
    553     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    554     * @return SHA-1 digest
    555     */
    556    public static byte[] sha1(final String data) {
    557        return sha1(StringUtils.getBytesUtf8(data));
    558    }
    559
    560    /**
    561     * Calculates the SHA-1 digest and returns the value as a hexadecimal string.
    562     *
    563     * @param data Data to digest
    564     * @return SHA-1 digest as a hexadecimal string
    565     * @since 1.7
    566     */
    567    public static String sha1Hex(final byte[] data) {
    568        return Hex.encodeHexString(sha1(data));
    569    }
    570
    571    /**
    572     * Calculates the SHA-1 digest and returns the value as a hexadecimal string.
    573     *
    574     * @param data Data to digest
    575     * @return SHA-1 digest as a hexadecimal string
    576     * @throws IOException On error reading from the stream
    577     * @since 1.7
    578     */
    579    public static String sha1Hex(final InputStream data) throws IOException {
    580        return Hex.encodeHexString(sha1(data));
    581    }
    582
    583    /**
    584     * Calculates the SHA-1 digest and returns the value as a hexadecimal string.
    585     *
    586     * @param data Data to digest
    587     * @return SHA-1 digest as a hexadecimal string
    588     * @since 1.7
    589     */
    590    public static String sha1Hex(final String data) {
    591        return Hex.encodeHexString(sha1(data));
    592    }
    593
    594    /**
    595     * Calculates the SHA-256 digest and returns the value as a {@code byte[]}.
    596     *
    597     * @param data Data to digest
    598     * @return SHA-256 digest
    599     * @since 1.4
    600     */
    601    public static byte[] sha256(final byte[] data) {
    602        return getSha256Digest().digest(data);
    603    }
    604
    605    /**
    606     * Calculates the SHA-256 digest and returns the value as a {@code byte[]}.
    607     *
    608     * @param data Data to digest
    609     * @return SHA-256 digest
    610     * @throws IOException On error reading from the stream
    611     * @since 1.4
    612     */
    613    public static byte[] sha256(final InputStream data) throws IOException {
    614        return digest(getSha256Digest(), data);
    615    }
    616
    617    /**
    618     * Calculates the SHA-256 digest and returns the value as a {@code byte[]}.
    619     *
    620     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    621     * @return SHA-256 digest
    622     * @since 1.4
    623     */
    624    public static byte[] sha256(final String data) {
    625        return sha256(StringUtils.getBytesUtf8(data));
    626    }
    627
    628    /**
    629     * Calculates the SHA-256 digest and returns the value as a hexadecimal string.
    630     *
    631     * @param data Data to digest
    632     * @return SHA-256 digest as a hexadecimal string
    633     * @since 1.4
    634     */
    635    public static String sha256Hex(final byte[] data) {
    636        return Hex.encodeHexString(sha256(data));
    637    }
    638
    639    /**
    640     * Calculates the SHA-256 digest and returns the value as a hexadecimal string.
    641     *
    642     * @param data Data to digest
    643     * @return SHA-256 digest as a hexadecimal string
    644     * @throws IOException On error reading from the stream
    645     * @since 1.4
    646     */
    647    public static String sha256Hex(final InputStream data) throws IOException {
    648        return Hex.encodeHexString(sha256(data));
    649    }
    650
    651    /**
    652     * Calculates the SHA-256 digest and returns the value as a hexadecimal string.
    653     *
    654     * @param data Data to digest
    655     * @return SHA-256 digest as a hexadecimal string
    656     * @since 1.4
    657     */
    658    public static String sha256Hex(final String data) {
    659        return Hex.encodeHexString(sha256(data));
    660    }
    661
    662    /**
    663     * Calculates the SHA3-224 digest and returns the value as a {@code byte[]}.
    664     *
    665     * @param data Data to digest
    666     * @return SHA3-224 digest
    667     * @since 1.12
    668     */
    669    public static byte[] sha3_224(final byte[] data) {
    670        return getSha3_224Digest().digest(data);
    671    }
    672
    673    /**
    674     * Calculates the SHA3-224 digest and returns the value as a {@code byte[]}.
    675     *
    676     * @param data Data to digest
    677     * @return SHA3-224 digest
    678     * @throws IOException On error reading from the stream
    679     * @since 1.12
    680     */
    681    public static byte[] sha3_224(final InputStream data) throws IOException {
    682        return digest(getSha3_224Digest(), data);
    683    }
    684
    685    /**
    686     * Calculates the SHA3-224 digest and returns the value as a {@code byte[]}.
    687     *
    688     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    689     * @return SHA3-224 digest
    690     * @since 1.12
    691     */
    692    public static byte[] sha3_224(final String data) {
    693        return sha3_224(StringUtils.getBytesUtf8(data));
    694    }
    695
    696    /**
    697     * Calculates the SHA3-224 digest and returns the value as a hexadecimal string.
    698     *
    699     * @param data Data to digest
    700     * @return SHA3-224 digest as a hexadecimal string
    701     * @since 1.12
    702     */
    703    public static String sha3_224Hex(final byte[] data) {
    704        return Hex.encodeHexString(sha3_224(data));
    705    }
    706
    707    /**
    708     * Calculates the SHA3-224 digest and returns the value as a hexadecimal string.
    709     *
    710     * @param data Data to digest
    711     * @return SHA3-224 digest as a hexadecimal string
    712     * @throws IOException On error reading from the stream
    713     * @since 1.12
    714     */
    715    public static String sha3_224Hex(final InputStream data) throws IOException {
    716        return Hex.encodeHexString(sha3_224(data));
    717    }
    718
    719    /**
    720     * Calculates the SHA3-224 digest and returns the value as a hexadecimal string.
    721     *
    722     * @param data Data to digest
    723     * @return SHA3-224 digest as a hexadecimal string
    724     * @since 1.12
    725     */
    726    public static String sha3_224Hex(final String data) {
    727        return Hex.encodeHexString(sha3_224(data));
    728    }
    729
    730    /**
    731     * Calculates the SHA3-256 digest and returns the value as a {@code byte[]}.
    732     *
    733     * @param data Data to digest
    734     * @return SHA3-256 digest
    735     * @since 1.12
    736     */
    737    public static byte[] sha3_256(final byte[] data) {
    738        return getSha3_256Digest().digest(data);
    739    }
    740
    741    /**
    742     * Calculates the SHA3-256 digest and returns the value as a {@code byte[]}.
    743     *
    744     * @param data Data to digest
    745     * @return SHA3-256 digest
    746     * @throws IOException On error reading from the stream
    747     * @since 1.12
    748     */
    749    public static byte[] sha3_256(final InputStream data) throws IOException {
    750        return digest(getSha3_256Digest(), data);
    751    }
    752
    753    /**
    754     * Calculates the SHA3-256 digest and returns the value as a {@code byte[]}.
    755     *
    756     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    757     * @return SHA3-256 digest
    758     * @since 1.12
    759     */
    760    public static byte[] sha3_256(final String data) {
    761        return sha3_256(StringUtils.getBytesUtf8(data));
    762    }
    763
    764    /**
    765     * Calculates the SHA3-256 digest and returns the value as a hexadecimal string.
    766     *
    767     * @param data Data to digest
    768     * @return SHA3-256 digest as a hexadecimal string
    769     * @since 1.12
    770     */
    771    public static String sha3_256Hex(final byte[] data) {
    772        return Hex.encodeHexString(sha3_256(data));
    773    }
    774
    775    /**
    776     * Calculates the SHA3-256 digest and returns the value as a hexadecimal string.
    777     *
    778     * @param data Data to digest
    779     * @return SHA3-256 digest as a hexadecimal string
    780     * @throws IOException On error reading from the stream
    781     * @since 1.12
    782     */
    783    public static String sha3_256Hex(final InputStream data) throws IOException {
    784        return Hex.encodeHexString(sha3_256(data));
    785    }
    786
    787    /**
    788     * Calculates the SHA3-256 digest and returns the value as a hexadecimal string.
    789     *
    790     * @param data Data to digest
    791     * @return SHA3-256 digest as a hexadecimal string
    792     * @since 1.12
    793     */
    794    public static String sha3_256Hex(final String data) {
    795        return Hex.encodeHexString(sha3_256(data));
    796    }
    797
    798    /**
    799     * Calculates the SHA3-384 digest and returns the value as a {@code byte[]}.
    800     *
    801     * @param data Data to digest
    802     * @return SHA3-384 digest
    803     * @since 1.12
    804     */
    805    public static byte[] sha3_384(final byte[] data) {
    806        return getSha3_384Digest().digest(data);
    807    }
    808
    809    /**
    810     * Calculates the SHA3-384 digest and returns the value as a {@code byte[]}.
    811     *
    812     * @param data Data to digest
    813     * @return SHA3-384 digest
    814     * @throws IOException On error reading from the stream
    815     * @since 1.12
    816     */
    817    public static byte[] sha3_384(final InputStream data) throws IOException {
    818        return digest(getSha3_384Digest(), data);
    819    }
    820
    821    /**
    822     * Calculates the SHA3-384 digest and returns the value as a {@code byte[]}.
    823     *
    824     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    825     * @return SHA3-384 digest
    826     * @since 1.12
    827     */
    828    public static byte[] sha3_384(final String data) {
    829        return sha3_384(StringUtils.getBytesUtf8(data));
    830    }
    831
    832    /**
    833     * Calculates the SHA3-384 digest and returns the value as a hexadecimal string.
    834     *
    835     * @param data Data to digest
    836     * @return SHA3-384 digest as a hexadecimal string
    837     * @since 1.12
    838     */
    839    public static String sha3_384Hex(final byte[] data) {
    840        return Hex.encodeHexString(sha3_384(data));
    841    }
    842
    843    /**
    844     * Calculates the SHA3-384 digest and returns the value as a hexadecimal string.
    845     *
    846     * @param data Data to digest
    847     * @return SHA3-384 digest as a hexadecimal string
    848     * @throws IOException On error reading from the stream
    849     * @since 1.12
    850     */
    851    public static String sha3_384Hex(final InputStream data) throws IOException {
    852        return Hex.encodeHexString(sha3_384(data));
    853    }
    854
    855    /**
    856     * Calculates the SHA3-384 digest and returns the value as a hexadecimal string.
    857     *
    858     * @param data Data to digest
    859     * @return SHA3-384 digest as a hexadecimal string
    860     * @since 1.12
    861     */
    862    public static String sha3_384Hex(final String data) {
    863        return Hex.encodeHexString(sha3_384(data));
    864    }
    865
    866    /**
    867     * Calculates the SHA3-512 digest and returns the value as a {@code byte[]}.
    868     *
    869     * @param data Data to digest
    870     * @return SHA3-512 digest
    871     * @since 1.12
    872     */
    873    public static byte[] sha3_512(final byte[] data) {
    874        return getSha3_512Digest().digest(data);
    875    }
    876
    877    /**
    878     * Calculates the SHA3-512 digest and returns the value as a {@code byte[]}.
    879     *
    880     * @param data Data to digest
    881     * @return SHA3-512 digest
    882     * @throws IOException On error reading from the stream
    883     * @since 1.12
    884     */
    885    public static byte[] sha3_512(final InputStream data) throws IOException {
    886        return digest(getSha3_512Digest(), data);
    887    }
    888
    889    /**
    890     * Calculates the SHA3-512 digest and returns the value as a {@code byte[]}.
    891     *
    892     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    893     * @return SHA3-512 digest
    894     * @since 1.12
    895     */
    896    public static byte[] sha3_512(final String data) {
    897        return sha3_512(StringUtils.getBytesUtf8(data));
    898    }
    899
    900    /**
    901     * Calculates the SHA3-512 digest and returns the value as a hexadecimal string.
    902     *
    903     * @param data Data to digest
    904     * @return SHA3-512 digest as a hexadecimal string
    905     * @since 1.12
    906     */
    907    public static String sha3_512Hex(final byte[] data) {
    908        return Hex.encodeHexString(sha3_512(data));
    909    }
    910
    911    /**
    912     * Calculates the SHA3-512 digest and returns the value as a hexadecimal string.
    913     *
    914     * @param data Data to digest
    915     * @return SHA3-512 digest as a hexadecimal string
    916     * @throws IOException On error reading from the stream
    917     * @since 1.12
    918     */
    919    public static String sha3_512Hex(final InputStream data) throws IOException {
    920        return Hex.encodeHexString(sha3_512(data));
    921    }
    922
    923    /**
    924     * Calculates the SHA3-512 digest and returns the value as a hexadecimal string.
    925     *
    926     * @param data Data to digest
    927     * @return SHA3-512 digest as a hexadecimal string
    928     * @since 1.12
    929     */
    930    public static String sha3_512Hex(final String data) {
    931        return Hex.encodeHexString(sha3_512(data));
    932    }
    933
    934    /**
    935     * Calculates the SHA-384 digest and returns the value as a {@code byte[]}.
    936     *
    937     * @param data Data to digest
    938     * @return SHA-384 digest
    939     * @since 1.4
    940     */
    941    public static byte[] sha384(final byte[] data) {
    942        return getSha384Digest().digest(data);
    943    }
    944
    945    /**
    946     * Calculates the SHA-384 digest and returns the value as a {@code byte[]}.
    947     *
    948     * @param data Data to digest
    949     * @return SHA-384 digest
    950     * @throws IOException On error reading from the stream
    951     * @since 1.4
    952     */
    953    public static byte[] sha384(final InputStream data) throws IOException {
    954        return digest(getSha384Digest(), data);
    955    }
    956
    957    /**
    958     * Calculates the SHA-384 digest and returns the value as a {@code byte[]}.
    959     *
    960     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    961     * @return SHA-384 digest
    962     * @since 1.4
    963     */
    964    public static byte[] sha384(final String data) {
    965        return sha384(StringUtils.getBytesUtf8(data));
    966    }
    967
    968    /**
    969     * Calculates the SHA-384 digest and returns the value as a hexadecimal string.
    970     *
    971     * @param data Data to digest
    972     * @return SHA-384 digest as a hexadecimal string
    973     * @since 1.4
    974     */
    975    public static String sha384Hex(final byte[] data) {
    976        return Hex.encodeHexString(sha384(data));
    977    }
    978
    979    /**
    980     * Calculates the SHA-384 digest and returns the value as a hexadecimal string.
    981     *
    982     * @param data Data to digest
    983     * @return SHA-384 digest as a hexadecimal string
    984     * @throws IOException On error reading from the stream
    985     * @since 1.4
    986     */
    987    public static String sha384Hex(final InputStream data) throws IOException {
    988        return Hex.encodeHexString(sha384(data));
    989    }
    990
    991    /**
    992     * Calculates the SHA-384 digest and returns the value as a hexadecimal string.
    993     *
    994     * @param data Data to digest
    995     * @return SHA-384 digest as a hexadecimal string
    996     * @since 1.4
    997     */
    998    public static String sha384Hex(final String data) {
    999        return Hex.encodeHexString(sha384(data));
    1000    }
    1001
    1002    /**
    1003     * Calculates the SHA-512 digest and returns the value as a {@code byte[]}.
    1004     *
    1005     * @param data Data to digest
    1006     * @return SHA-512 digest
    1007     * @since 1.4
    1008     */
    1009    public static byte[] sha512(final byte[] data) {
    1010        return getSha512Digest().digest(data);
    1011    }
    1012
    1013    /**
    1014     * Calculates the SHA-512 digest and returns the value as a {@code byte[]}.
    1015     *
    1016     * @param data Data to digest
    1017     * @return SHA-512 digest
    1018     * @throws IOException On error reading from the stream
    1019     * @since 1.4
    1020     */
    1021    public static byte[] sha512(final InputStream data) throws IOException {
    1022        return digest(getSha512Digest(), data);
    1023    }
    1024
    1025    /**
    1026     * Calculates the SHA-512 digest and returns the value as a {@code byte[]}.
    1027     *
    1028     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    1029     * @return SHA-512 digest
    1030     * @since 1.4
    1031     */
    1032    public static byte[] sha512(final String data) {
    1033        return sha512(StringUtils.getBytesUtf8(data));
    1034    }
    1035
    1036    /**
    1037     * Calculates the SHA-512/224 digest and returns the value as a {@code byte[]}.
    1038     *
    1039     * @param data Data to digest
    1040     * @return SHA-512/224 digest
    1041     * @since 1.14
    1042     */
    1043    public static byte[] sha512_224(final byte[] data) {
    1044        return getSha512_224Digest().digest(data);
    1045    }
    1046
    1047    /**
    1048     * Calculates the SHA-512/224 digest and returns the value as a {@code byte[]}.
    1049     *
    1050     * @param data Data to digest
    1051     * @return SHA-512/224 digest
    1052     * @throws IOException On error reading from the stream
    1053     * @since 1.14
    1054     */
    1055    public static byte[] sha512_224(final InputStream data) throws IOException {
    1056        return digest(getSha512_224Digest(), data);
    1057    }
    1058
    1059    /**
    1060     * Calculates the SHA-512/224 digest and returns the value as a {@code byte[]}.
    1061     *
    1062     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    1063     * @return SHA-512/224 digest
    1064     * @since 1.14
    1065     */
    1066    public static byte[] sha512_224(final String data) {
    1067        return sha512_224(StringUtils.getBytesUtf8(data));
    1068    }
    1069
    1070    /**
    1071     * Calculates the SHA-512/224 digest and returns the value as a hexadecimal string.
    1072     *
    1073     * @param data Data to digest
    1074     * @return SHA-512/224 digest as a hexadecimal string
    1075     * @since 1.14
    1076     */
    1077    public static String sha512_224Hex(final byte[] data) {
    1078        return Hex.encodeHexString(sha512_224(data));
    1079    }
    1080
    1081    /**
    1082     * Calculates the SHA-512/224 digest and returns the value as a hexadecimal string.
    1083     *
    1084     * @param data Data to digest
    1085     * @return SHA-512/224 digest as a hexadecimal string
    1086     * @throws IOException On error reading from the stream
    1087     * @since 1.14
    1088     */
    1089    public static String sha512_224Hex(final InputStream data) throws IOException {
    1090        return Hex.encodeHexString(sha512_224(data));
    1091    }
    1092
    1093    /**
    1094     * Calculates the SHA-512/224 digest and returns the value as a hexadecimal string.
    1095     *
    1096     * @param data Data to digest
    1097     * @return SHA-512/224 digest as a hexadecimal string
    1098     * @since 1.14
    1099     */
    1100    public static String sha512_224Hex(final String data) {
    1101        return Hex.encodeHexString(sha512_224(data));
    1102    }
    1103
    1104    /**
    1105     * Calculates the SHA-512/256 digest and returns the value as a {@code byte[]}.
    1106     *
    1107     * @param data Data to digest
    1108     * @return SHA-512/256 digest
    1109     * @since 1.14
    1110     */
    1111    public static byte[] sha512_256(final byte[] data) {
    1112        return getSha512_256Digest().digest(data);
    1113    }
    1114
    1115    /**
    1116     * Calculates the SHA-512/256 digest and returns the value as a {@code byte[]}.
    1117     *
    1118     * @param data Data to digest
    1119     * @return SHA-512/256 digest
    1120     * @throws IOException On error reading from the stream
    1121     * @since 1.14
    1122     */
    1123    public static byte[] sha512_256(final InputStream data) throws IOException {
    1124        return digest(getSha512_256Digest(), data);
    1125    }
    1126
    1127    /**
    1128     * Calculates the SHA-512/256 digest and returns the value as a {@code byte[]}.
    1129     *
    1130     * @param data Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    1131     * @return SHA-512/224 digest
    1132     * @since 1.14
    1133     */
    1134    public static byte[] sha512_256(final String data) {
    1135        return sha512_256(StringUtils.getBytesUtf8(data));
    1136    }
    1137
    1138    /**
    1139     * Calculates the SHA-512/256 digest and returns the value as a hexadecimal string.
    1140     *
    1141     * @param data Data to digest
    1142     * @return SHA-512/256 digest as a hexadecimal string
    1143     * @since 1.14
    1144     */
    1145    public static String sha512_256Hex(final byte[] data) {
    1146        return Hex.encodeHexString(sha512_256(data));
    1147    }
    1148
    1149    /**
    1150     * Calculates the SHA-512/256 digest and returns the value as a hexadecimal string.
    1151     *
    1152     * @param data Data to digest
    1153     * @return SHA-512/256 digest as a hexadecimal string
    1154     * @throws IOException On error reading from the stream
    1155     * @since 1.14
    1156     */
    1157    public static String sha512_256Hex(final InputStream data) throws IOException {
    1158        return Hex.encodeHexString(sha512_256(data));
    1159    }
    1160
    1161    /**
    1162     * Calculates the SHA-512/256 digest and returns the value as a hexadecimal string.
    1163     *
    1164     * @param data Data to digest
    1165     * @return SHA-512/256 digest as a hexadecimal string
    1166     * @since 1.14
    1167     */
    1168    public static String sha512_256Hex(final String data) {
    1169        return Hex.encodeHexString(sha512_256(data));
    1170    }
    1171
    1172    /**
    1173     * Calculates the SHA-512 digest and returns the value as a hexadecimal string.
    1174     *
    1175     * @param data Data to digest
    1176     * @return SHA-512 digest as a hexadecimal string
    1177     * @since 1.4
    1178     */
    1179    public static String sha512Hex(final byte[] data) {
    1180        return Hex.encodeHexString(sha512(data));
    1181    }
    1182
    1183    /**
    1184     * Calculates the SHA-512 digest and returns the value as a hexadecimal string.
    1185     *
    1186     * @param data Data to digest
    1187     * @return SHA-512 digest as a hexadecimal string
    1188     * @throws IOException On error reading from the stream
    1189     * @since 1.4
    1190     */
    1191    public static String sha512Hex(final InputStream data) throws IOException {
    1192        return Hex.encodeHexString(sha512(data));
    1193    }
    1194
    1195    /**
    1196     * Calculates the SHA-512 digest and returns the value as a hexadecimal string.
    1197     *
    1198     * @param data Data to digest
    1199     * @return SHA-512 digest as a hexadecimal string
    1200     * @since 1.4
    1201     */
    1202    public static String sha512Hex(final String data) {
    1203        return Hex.encodeHexString(sha512(data));
    1204    }
    1205
    1206    /**
    1207     * Calculates the SHA-1 digest and returns the value as a hexadecimal string.
    1208     *
    1209     * @param data Data to digest
    1210     * @return SHA-1 digest as a hexadecimal string
    1211     * @deprecated (1.11) Use {@link #sha1Hex(byte[])}
    1212     */
    1213    @Deprecated
    1214    public static String shaHex(final byte[] data) {
    1215        return sha1Hex(data);
    1216    }
    1217
    1218    /**
    1219     * Calculates the SHA-1 digest and returns the value as a hexadecimal string.
    1220     *
    1221     * @param data Data to digest
    1222     * @return SHA-1 digest as a hexadecimal string
    1223     * @throws IOException On error reading from the stream
    1224     * @since 1.4
    1225     * @deprecated (1.11) Use {@link #sha1Hex(InputStream)}
    1226     */
    1227    @Deprecated
    1228    public static String shaHex(final InputStream data) throws IOException {
    1229        return sha1Hex(data);
    1230    }
    1231
    1232    /**
    1233     * Calculates the SHA-1 digest and returns the value as a hexadecimal string.
    1234     *
    1235     * @param data Data to digest
    1236     * @return SHA-1 digest as a hexadecimal string
    1237     * @deprecated (1.11) Use {@link #sha1Hex(String)}
    1238     */
    1239    @Deprecated
    1240    public static String shaHex(final String data) {
    1241        return sha1Hex(data);
    1242    }
    1243
    1244    /**
    1245     * Updates the given {@link MessageDigest}.
    1246     *
    1247     * @param messageDigest the {@link MessageDigest} to update
    1248     * @param valueToDigest the value to update the {@link MessageDigest} with
    1249     * @return the updated {@link MessageDigest}
    1250     * @since 1.7
    1251     */
    1252    public static MessageDigest updateDigest(final MessageDigest messageDigest, final byte[] valueToDigest) {
    1253        messageDigest.update(valueToDigest);
    1254        return messageDigest;
    1255    }
    1256
    1257    /**
    1258     * Updates the given {@link MessageDigest}.
    1259     *
    1260     * @param messageDigest the {@link MessageDigest} to update
    1261     * @param valueToDigest the value to update the {@link MessageDigest} with
    1262     * @return the updated {@link MessageDigest}
    1263     * @since 1.11
    1264     */
    1265    public static MessageDigest updateDigest(final MessageDigest messageDigest, final ByteBuffer valueToDigest) {
    1266        messageDigest.update(valueToDigest);
    1267        return messageDigest;
    1268    }
    1269
    1270    /**
    1271     * Reads through a File and updates the digest for the data
    1272     *
    1273     * @param digest The MessageDigest to use (e.g. MD5)
    1274     * @param data   Data to digest
    1275     * @return the digest
    1276     * @throws IOException On error reading from the stream
    1277     * @since 1.11
    1278     */
    1279    public static MessageDigest updateDigest(final MessageDigest digest, final File data) throws IOException {
    1280        try (final BufferedInputStream inputStream = new BufferedInputStream(new FileInputStream(data))) {
    1281            return updateDigest(digest, inputStream);
    1282        }
    1283    }
    1284
    1285    /**
    1286     * Reads through a RandomAccessFile and updates the digest for the data using non-blocking-io (NIO).
    1287     *
    1288     * TODO Decide if this should be public.
    1289     *
    1290     * @param digest The MessageDigest to use (e.g. MD5)
    1291     * @param data   Data to digest
    1292     * @return the digest
    1293     * @throws IOException On error reading from the stream
    1294     * @since 1.14
    1295     */
    1296    private static MessageDigest updateDigest(final MessageDigest digest, final FileChannel data) throws IOException {
    1297        final ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
    1298        while (data.read(buffer) > 0) {
    1299            buffer.flip();
    1300            digest.update(buffer);
    1301            buffer.clear();
    1302        }
    1303        return digest;
    1304    }
    1305
    1306    /**
    1307     * Reads through an InputStream and updates the digest for the data
    1308     *
    1309     * @param digest      The MessageDigest to use (e.g. MD5)
    1310     * @param inputStream Data to digest
    1311     * @return the digest
    1312     * @throws IOException On error reading from the stream
    1313     * @since 1.8
    1314     */
    1315    public static MessageDigest updateDigest(final MessageDigest digest, final InputStream inputStream) throws IOException {
    1316        final byte[] buffer = new byte[BUFFER_SIZE];
    1317        int read = inputStream.read(buffer, 0, BUFFER_SIZE);
    1318
    1319        while (read > -1) {
    1320            digest.update(buffer, 0, read);
    1321            read = inputStream.read(buffer, 0, BUFFER_SIZE);
    1322        }
    1323
    1324        return digest;
    1325    }
    1326
    1327    /**
    1328     * Reads through a Path and updates the digest for the data
    1329     *
    1330     * @param digest  The MessageDigest to use (e.g. MD5)
    1331     * @param path    Data to digest
    1332     * @param options options How to open the file
    1333     * @return the digest
    1334     * @throws IOException On error reading from the stream
    1335     * @since 1.14
    1336     */
    1337    public static MessageDigest updateDigest(final MessageDigest digest, final Path path, final OpenOption... options) throws IOException {
    1338        try (final BufferedInputStream inputStream = new BufferedInputStream(Files.newInputStream(path, options))) {
    1339            return updateDigest(digest, inputStream);
    1340        }
    1341    }
    1342
    1343    /**
    1344     * Reads through a RandomAccessFile and updates the digest for the data using non-blocking-io (NIO)
    1345     *
    1346     * @param digest The MessageDigest to use (e.g. MD5)
    1347     * @param data   Data to digest
    1348     * @return the digest
    1349     * @throws IOException On error reading from the stream
    1350     * @since 1.14
    1351     */
    1352    @SuppressWarnings("resource") // Closing RandomAccessFile closes the channel.
    1353    public static MessageDigest updateDigest(final MessageDigest digest, final RandomAccessFile data) throws IOException {
    1354        return updateDigest(digest, data.getChannel());
    1355    }
    1356
    1357    /**
    1358     * Updates the given {@link MessageDigest} from a String (converted to bytes using UTF-8).
    1359     * <p>
    1360     * To update the digest using a different charset for the conversion, convert the String to a byte array using
    1361     * {@link String#getBytes(java.nio.charset.Charset)} and pass that to the {@link DigestUtils#updateDigest(MessageDigest, byte[])} method
    1362     *
    1363     * @param messageDigest the {@link MessageDigest} to update
    1364     * @param valueToDigest the value to update the {@link MessageDigest} with; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
    1365     * @return the updated {@link MessageDigest}
    1366     * @since 1.7
    1367     */
    1368    public static MessageDigest updateDigest(final MessageDigest messageDigest, final String valueToDigest) {
    1369        messageDigest.update(StringUtils.getBytesUtf8(valueToDigest));
    1370        return messageDigest;
    1371    }
    1372
    1373    private final MessageDigest messageDigest;
    1374
    1375    /**
    1376     * Preserves binary compatibility only. As for previous versions does not provide useful behavior
    1377     *
    1378     * @deprecated since 1.11; only useful to preserve binary compatibility
    1379     */
    1380    @Deprecated
    1381    public DigestUtils() {
    1382        this.messageDigest = null;
    1383    }
    1384
    1385    /**
    1386     * Creates an instance using the provided {@link MessageDigest} parameter.
    1387     *
    1388     * This can then be used to create digests using methods such as {@link #digest(byte[])} and {@link #digestAsHex(File)}.
    1389     *
    1390     * @param digest the {@link MessageDigest} to use
    1391     * @since 1.11
    1392     */
    1393    public DigestUtils(final MessageDigest digest) {
    1394        this.messageDigest = digest;
    1395    }
    1396
    1397    /**
    1398     * Creates an instance using the provided {@link MessageDigest} parameter.
    1399     *
    1400     * This can then be used to create digests using methods such as {@link #digest(byte[])} and {@link #digestAsHex(File)}.
    1401     *
    1402     * @param name the name of the {@link MessageDigest} to use
    1403     * @see #getDigest(String)
    1404     * @throws IllegalArgumentException when a {@link NoSuchAlgorithmException} is caught.
    1405     * @since 1.11
    1406     */
    1407    public DigestUtils(final String name) {
    1408        this(getDigest(name));
    1409    }
    1410
    1411    /**
    1412     * Reads through a byte array and returns the digest for the data.
    1413     *
    1414     * @param data Data to digest
    1415     * @return the digest
    1416     * @since 1.11
    1417     */
    1418    public byte[] digest(final byte[] data) {
    1419        return updateDigest(messageDigest, data).digest();
    1420    }
    1421
    1422    /**
    1423     * Reads through a ByteBuffer and returns the digest for the data
    1424     *
    1425     * @param data Data to digest
    1426     * @return the digest
    1427     *
    1428     * @since 1.11
    1429     */
    1430    public byte[] digest(final ByteBuffer data) {
    1431        return updateDigest(messageDigest, data).digest();
    1432    }
    1433
    1434    /**
    1435     * Reads through a File and returns the digest for the data
    1436     *
    1437     * @param data Data to digest
    1438     * @return the digest
    1439     * @throws IOException On error reading from the stream
    1440     * @since 1.11
    1441     */
    1442    public byte[] digest(final File data) throws IOException {
    1443        return updateDigest(messageDigest, data).digest();
    1444    }
    1445
    1446    /**
    1447     * Reads through an InputStream and returns the digest for the data
    1448     *
    1449     * @param data Data to digest
    1450     * @return the digest
    1451     * @throws IOException On error reading from the stream
    1452     * @since 1.11
    1453     */
    1454    public byte[] digest(final InputStream data) throws IOException {
    1455        return updateDigest(messageDigest, data).digest();
    1456    }
    1457
    1458    /**
    1459     * Reads through a File and returns the digest for the data
    1460     *
    1461     * @param data    Data to digest
    1462     * @param options options How to open the file
    1463     * @return the digest
    1464     * @throws IOException On error reading from the stream
    1465     * @since 1.14
    1466     */
    1467    public byte[] digest(final Path data, final OpenOption... options) throws IOException {
    1468        return updateDigest(messageDigest, data, options).digest();
    1469    }
    1470
    1471    /**
    1472     * Reads through a byte array and returns the digest for the data.
    1473     *
    1474     * @param data Data to digest treated as UTF-8 string
    1475     * @return the digest
    1476     * @since 1.11
    1477     */
    1478    public byte[] digest(final String data) {
    1479        return updateDigest(messageDigest, data).digest();
    1480    }
    1481
    1482    /**
    1483     * Reads through a byte array and returns the digest for the data.
    1484     *
    1485     * @param data Data to digest
    1486     * @return the digest as a hexadecimal string
    1487     * @since 1.11
    1488     */
    1489    public String digestAsHex(final byte[] data) {
    1490        return Hex.encodeHexString(digest(data));
    1491    }
    1492
    1493    /**
    1494     * Reads through a ByteBuffer and returns the digest for the data
    1495     *
    1496     * @param data Data to digest
    1497     * @return the digest as a hexadecimal string
    1498     *
    1499     * @since 1.11
    1500     */
    1501    public String digestAsHex(final ByteBuffer data) {
    1502        return Hex.encodeHexString(digest(data));
    1503    }
    1504
    1505    /**
    1506     * Reads through a File and returns the digest for the data
    1507     *
    1508     * @param data Data to digest
    1509     * @return the digest as a hexadecimal string
    1510     * @throws IOException On error reading from the stream
    1511     * @since 1.11
    1512     */
    1513    public String digestAsHex(final File data) throws IOException {
    1514        return Hex.encodeHexString(digest(data));
    1515    }
    1516
    1517    /**
    1518     * Reads through an InputStream and returns the digest for the data
    1519     *
    1520     * @param data Data to digest
    1521     * @return the digest as a hexadecimal string
    1522     * @throws IOException On error reading from the stream
    1523     * @since 1.11
    1524     */
    1525    public String digestAsHex(final InputStream data) throws IOException {
    1526        return Hex.encodeHexString(digest(data));
    1527    }
    1528
    1529    /**
    1530     * Reads through a File and returns the digest for the data
    1531     *
    1532     * @param data    Data to digest
    1533     * @param options options How to open the file
    1534     * @return the digest as a hexadecimal string
    1535     * @throws IOException On error reading from the stream
    1536     * @since 1.11
    1537     */
    1538    public String digestAsHex(final Path data, final OpenOption... options) throws IOException {
    1539        return Hex.encodeHexString(digest(data, options));
    1540    }
    1541
    1542    /**
    1543     * Reads through a byte array and returns the digest for the data.
    1544     *
    1545     * @param data Data to digest treated as UTF-8 string
    1546     * @return the digest as a hexadecimal string
    1547     * @since 1.11
    1548     */
    1549    public String digestAsHex(final String data) {
    1550        return Hex.encodeHexString(digest(data));
    1551    }
    1552
    1553    /**
    1554     * Returns the message digest instance.
    1555     *
    1556     * @return the message digest instance
    1557     * @since 1.11
    1558     */
    1559    public MessageDigest getMessageDigest() {
    1560        return messageDigest;
    1561    }
    1562
    1563}