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