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