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