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 }