001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018package org.apache.commons.codec.digest;
019
020import java.io.IOException;
021import java.io.InputStream;
022import java.security.MessageDigest;
023import java.security.NoSuchAlgorithmException;
024
025import org.apache.commons.codec.binary.Hex;
026import org.apache.commons.codec.binary.StringUtils;
027
028/**
029 * Operations to simplify common {@link java.security.MessageDigest} tasks.
030 * This class is immutable and thread-safe.
031 *
032 * @version $Id: DigestUtils.java 1563226 2014-01-31 19:38:06Z ggregory $
033 */
034public class DigestUtils {
035
036    private static final int STREAM_BUFFER_LENGTH = 1024;
037
038    /**
039     * Read through an InputStream and returns the digest for the data
040     *
041     * @param digest
042     *            The MessageDigest to use (e.g. MD5)
043     * @param data
044     *            Data to digest
045     * @return the digest
046     * @throws IOException
047     *             On error reading from the stream
048     */
049    private static byte[] digest(final MessageDigest digest, final InputStream data) throws IOException {
050        return updateDigest(digest, data).digest();
051    }
052
053    /**
054     * Returns a <code>MessageDigest</code> for the given <code>algorithm</code>.
055     *
056     * @param algorithm
057     *            the name of the algorithm requested. See <a
058     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">Appendix A in the Java
059     *            Cryptography Architecture Reference Guide</a> for information about standard algorithm
060     *            names.
061     * @return A digest instance.
062     * @see MessageDigest#getInstance(String)
063     * @throws IllegalArgumentException
064     *             when a {@link NoSuchAlgorithmException} is caught.
065     */
066    public static MessageDigest getDigest(final String algorithm) {
067        try {
068            return MessageDigest.getInstance(algorithm);
069        } catch (final NoSuchAlgorithmException e) {
070            throw new IllegalArgumentException(e);
071        }
072    }
073
074    /**
075     * Returns an MD2 MessageDigest.
076     *
077     * @return An MD2 digest instance.
078     * @throws IllegalArgumentException
079     *             when a {@link NoSuchAlgorithmException} is caught, which should never happen because MD2 is a
080     *             built-in algorithm
081     * @see MessageDigestAlgorithms#MD2
082     * @since 1.7
083     */
084    public static MessageDigest getMd2Digest() {
085        return getDigest(MessageDigestAlgorithms.MD2);
086    }
087
088    /**
089     * Returns an MD5 MessageDigest.
090     *
091     * @return An MD5 digest instance.
092     * @throws IllegalArgumentException
093     *             when a {@link NoSuchAlgorithmException} is caught, which should never happen because MD5 is a
094     *             built-in algorithm
095     * @see MessageDigestAlgorithms#MD5
096     */
097    public static MessageDigest getMd5Digest() {
098        return getDigest(MessageDigestAlgorithms.MD5);
099    }
100
101    /**
102     * Returns an SHA-1 digest.
103     *
104     * @return An SHA-1 digest instance.
105     * @throws IllegalArgumentException
106     *             when a {@link NoSuchAlgorithmException} is caught, which should never happen because SHA-1 is a
107     *             built-in algorithm
108     * @see MessageDigestAlgorithms#SHA_1
109     * @since 1.7
110     */
111    public static MessageDigest getSha1Digest() {
112        return getDigest(MessageDigestAlgorithms.SHA_1);
113    }
114
115    /**
116     * Returns an SHA-256 digest.
117     * <p>
118     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
119     * </p>
120     *
121     * @return An SHA-256 digest instance.
122     * @throws IllegalArgumentException
123     *             when a {@link NoSuchAlgorithmException} is caught, which should never happen because SHA-256 is a
124     *             built-in algorithm
125     * @see MessageDigestAlgorithms#SHA_256
126     */
127    public static MessageDigest getSha256Digest() {
128        return getDigest(MessageDigestAlgorithms.SHA_256);
129    }
130
131    /**
132     * Returns an SHA-384 digest.
133     * <p>
134     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
135     * </p>
136     *
137     * @return An SHA-384 digest instance.
138     * @throws IllegalArgumentException
139     *             when a {@link NoSuchAlgorithmException} is caught, which should never happen because SHA-384 is a
140     *             built-in algorithm
141     * @see MessageDigestAlgorithms#SHA_384
142     */
143    public static MessageDigest getSha384Digest() {
144        return getDigest(MessageDigestAlgorithms.SHA_384);
145    }
146
147    /**
148     * Returns an SHA-512 digest.
149     * <p>
150     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
151     * </p>
152     *
153     * @return An SHA-512 digest instance.
154     * @throws IllegalArgumentException
155     *             when a {@link NoSuchAlgorithmException} is caught, which should never happen because SHA-512 is a
156     *             built-in algorithm
157     * @see MessageDigestAlgorithms#SHA_512
158     */
159    public static MessageDigest getSha512Digest() {
160        return getDigest(MessageDigestAlgorithms.SHA_512);
161    }
162
163    /**
164     * Returns an SHA-1 digest.
165     *
166     * @return An SHA-1 digest instance.
167     * @throws IllegalArgumentException
168     *             when a {@link NoSuchAlgorithmException} is caught
169     * @deprecated Use {@link #getSha1Digest()}
170     */
171    @Deprecated
172    public static MessageDigest getShaDigest() {
173        return getSha1Digest();
174    }
175
176    /**
177     * Calculates the MD2 digest and returns the value as a 16 element <code>byte[]</code>.
178     *
179     * @param data
180     *            Data to digest
181     * @return MD2 digest
182     * @since 1.7
183     */
184    public static byte[] md2(final byte[] data) {
185        return getMd2Digest().digest(data);
186    }
187
188    /**
189     * Calculates the MD2 digest and returns the value as a 16 element <code>byte[]</code>.
190     *
191     * @param data
192     *            Data to digest
193     * @return MD2 digest
194     * @throws IOException
195     *             On error reading from the stream
196     * @since 1.7
197     */
198    public static byte[] md2(final InputStream data) throws IOException {
199        return digest(getMd2Digest(), data);
200    }
201
202    /**
203     * Calculates the MD2 digest and returns the value as a 16 element <code>byte[]</code>.
204     *
205     * @param data
206     *            Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
207     * @return MD2 digest
208     * @since 1.7
209     */
210    public static byte[] md2(final String data) {
211        return md2(StringUtils.getBytesUtf8(data));
212    }
213
214    /**
215     * Calculates the MD2 digest and returns the value as a 32 character hex string.
216     *
217     * @param data
218     *            Data to digest
219     * @return MD2 digest as a hex string
220     * @since 1.7
221     */
222    public static String md2Hex(final byte[] data) {
223        return Hex.encodeHexString(md2(data));
224    }
225
226    /**
227     * Calculates the MD2 digest and returns the value as a 32 character hex string.
228     *
229     * @param data
230     *            Data to digest
231     * @return MD2 digest as a hex string
232     * @throws IOException
233     *             On error reading from the stream
234     * @since 1.7
235     */
236    public static String md2Hex(final InputStream data) throws IOException {
237        return Hex.encodeHexString(md2(data));
238    }
239
240    /**
241     * Calculates the MD2 digest and returns the value as a 32 character hex string.
242     *
243     * @param data
244     *            Data to digest
245     * @return MD2 digest as a hex string
246     * @since 1.7
247     */
248    public static String md2Hex(final String data) {
249        return Hex.encodeHexString(md2(data));
250    }
251
252    /**
253     * Calculates the MD5 digest and returns the value as a 16 element <code>byte[]</code>.
254     *
255     * @param data
256     *            Data to digest
257     * @return MD5 digest
258     */
259    public static byte[] md5(final byte[] data) {
260        return getMd5Digest().digest(data);
261    }
262
263    /**
264     * Calculates the MD5 digest and returns the value as a 16 element <code>byte[]</code>.
265     *
266     * @param data
267     *            Data to digest
268     * @return MD5 digest
269     * @throws IOException
270     *             On error reading from the stream
271     * @since 1.4
272     */
273    public static byte[] md5(final InputStream data) throws IOException {
274        return digest(getMd5Digest(), data);
275    }
276
277    /**
278     * Calculates the MD5 digest and returns the value as a 16 element <code>byte[]</code>.
279     *
280     * @param data
281     *            Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
282     * @return MD5 digest
283     */
284    public static byte[] md5(final String data) {
285        return md5(StringUtils.getBytesUtf8(data));
286    }
287
288    /**
289     * Calculates the MD5 digest and returns the value as a 32 character hex string.
290     *
291     * @param data
292     *            Data to digest
293     * @return MD5 digest as a hex string
294     */
295    public static String md5Hex(final byte[] data) {
296        return Hex.encodeHexString(md5(data));
297    }
298
299    /**
300     * Calculates the MD5 digest and returns the value as a 32 character hex string.
301     *
302     * @param data
303     *            Data to digest
304     * @return MD5 digest as a hex string
305     * @throws IOException
306     *             On error reading from the stream
307     * @since 1.4
308     */
309    public static String md5Hex(final InputStream data) throws IOException {
310        return Hex.encodeHexString(md5(data));
311    }
312
313    /**
314     * Calculates the MD5 digest and returns the value as a 32 character hex string.
315     *
316     * @param data
317     *            Data to digest
318     * @return MD5 digest as a hex string
319     */
320    public static String md5Hex(final String data) {
321        return Hex.encodeHexString(md5(data));
322    }
323
324    /**
325     * Calculates the SHA-1 digest and returns the value as a <code>byte[]</code>.
326     *
327     * @param data
328     *            Data to digest
329     * @return SHA-1 digest
330     * @deprecated Use {@link #sha1(byte[])}
331     */
332    @Deprecated
333    public static byte[] sha(final byte[] data) {
334        return sha1(data);
335    }
336
337    /**
338     * Calculates the SHA-1 digest and returns the value as a <code>byte[]</code>.
339     *
340     * @param data
341     *            Data to digest
342     * @return SHA-1 digest
343     * @throws IOException
344     *             On error reading from the stream
345     * @since 1.4
346     * @deprecated Use {@link #sha1(InputStream)}
347     */
348    @Deprecated
349    public static byte[] sha(final InputStream data) throws IOException {
350        return sha1(data);
351    }
352
353    /**
354     * Calculates the SHA-1 digest and returns the value as a <code>byte[]</code>.
355     *
356     * @param data
357     *            Data to digest
358     * @return SHA-1 digest
359     * @deprecated Use {@link #sha1(String)}
360     */
361    @Deprecated
362    public static byte[] sha(final String data) {
363        return sha1(data);
364    }
365
366    /**
367     * Calculates the SHA-1 digest and returns the value as a <code>byte[]</code>.
368     *
369     * @param data
370     *            Data to digest
371     * @return SHA-1 digest
372     * @since 1.7
373     */
374    public static byte[] sha1(final byte[] data) {
375        return getSha1Digest().digest(data);
376    }
377
378    /**
379     * Calculates the SHA-1 digest and returns the value as a <code>byte[]</code>.
380     *
381     * @param data
382     *            Data to digest
383     * @return SHA-1 digest
384     * @throws IOException
385     *             On error reading from the stream
386     * @since 1.7
387     */
388    public static byte[] sha1(final InputStream data) throws IOException {
389        return digest(getSha1Digest(), data);
390    }
391
392    /**
393     * Calculates the SHA-1 digest and returns the value as a <code>byte[]</code>.
394     *
395     * @param data
396     *            Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
397     * @return SHA-1 digest
398     */
399    public static byte[] sha1(final String data) {
400        return sha1(StringUtils.getBytesUtf8(data));
401    }
402
403    /**
404     * Calculates the SHA-1 digest and returns the value as a hex string.
405     *
406     * @param data
407     *            Data to digest
408     * @return SHA-1 digest as a hex string
409     * @since 1.7
410     */
411    public static String sha1Hex(final byte[] data) {
412        return Hex.encodeHexString(sha1(data));
413    }
414
415    /**
416     * Calculates the SHA-1 digest and returns the value as a hex string.
417     *
418     * @param data
419     *            Data to digest
420     * @return SHA-1 digest as a hex string
421     * @throws IOException
422     *             On error reading from the stream
423     * @since 1.7
424     */
425    public static String sha1Hex(final InputStream data) throws IOException {
426        return Hex.encodeHexString(sha1(data));
427    }
428
429    /**
430     * Calculates the SHA-1 digest and returns the value as a hex string.
431     *
432     * @param data
433     *            Data to digest
434     * @return SHA-1 digest as a hex string
435     * @since 1.7
436     */
437    public static String sha1Hex(final String data) {
438        return Hex.encodeHexString(sha1(data));
439    }
440
441    /**
442     * Calculates the SHA-256 digest and returns the value as a <code>byte[]</code>.
443     * <p>
444     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
445     * </p>
446     *
447     * @param data
448     *            Data to digest
449     * @return SHA-256 digest
450     * @since 1.4
451     */
452    public static byte[] sha256(final byte[] data) {
453        return getSha256Digest().digest(data);
454    }
455
456    /**
457     * Calculates the SHA-256 digest and returns the value as a <code>byte[]</code>.
458     * <p>
459     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
460     * </p>
461     *
462     * @param data
463     *            Data to digest
464     * @return SHA-256 digest
465     * @throws IOException
466     *             On error reading from the stream
467     * @since 1.4
468     */
469    public static byte[] sha256(final InputStream data) throws IOException {
470        return digest(getSha256Digest(), data);
471    }
472
473    /**
474     * Calculates the SHA-256 digest and returns the value as a <code>byte[]</code>.
475     * <p>
476     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
477     * </p>
478     *
479     * @param data
480     *            Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
481     * @return SHA-256 digest
482     * @since 1.4
483     */
484    public static byte[] sha256(final String data) {
485        return sha256(StringUtils.getBytesUtf8(data));
486    }
487
488    /**
489     * Calculates the SHA-256 digest and returns the value as a hex string.
490     * <p>
491     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
492     * </p>
493     *
494     * @param data
495     *            Data to digest
496     * @return SHA-256 digest as a hex string
497     * @since 1.4
498     */
499    public static String sha256Hex(final byte[] data) {
500        return Hex.encodeHexString(sha256(data));
501    }
502
503    /**
504     * Calculates the SHA-256 digest and returns the value as a hex string.
505     * <p>
506     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
507     * </p>
508     *
509     * @param data
510     *            Data to digest
511     * @return SHA-256 digest as a hex string
512     * @throws IOException
513     *             On error reading from the stream
514     * @since 1.4
515     */
516    public static String sha256Hex(final InputStream data) throws IOException {
517        return Hex.encodeHexString(sha256(data));
518    }
519
520    /**
521     * Calculates the SHA-256 digest and returns the value as a hex string.
522     * <p>
523     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
524     * </p>
525     *
526     * @param data
527     *            Data to digest
528     * @return SHA-256 digest as a hex string
529     * @since 1.4
530     */
531    public static String sha256Hex(final String data) {
532        return Hex.encodeHexString(sha256(data));
533    }
534
535    /**
536     * Calculates the SHA-384 digest and returns the value as a <code>byte[]</code>.
537     * <p>
538     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
539     * </p>
540     *
541     * @param data
542     *            Data to digest
543     * @return SHA-384 digest
544     * @since 1.4
545     */
546    public static byte[] sha384(final byte[] data) {
547        return getSha384Digest().digest(data);
548    }
549
550    /**
551     * Calculates the SHA-384 digest and returns the value as a <code>byte[]</code>.
552     * <p>
553     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
554     * </p>
555     *
556     * @param data
557     *            Data to digest
558     * @return SHA-384 digest
559     * @throws IOException
560     *             On error reading from the stream
561     * @since 1.4
562     */
563    public static byte[] sha384(final InputStream data) throws IOException {
564        return digest(getSha384Digest(), data);
565    }
566
567    /**
568     * Calculates the SHA-384 digest and returns the value as a <code>byte[]</code>.
569     * <p>
570     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
571     * </p>
572     *
573     * @param data
574     *            Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
575     * @return SHA-384 digest
576     * @since 1.4
577     */
578    public static byte[] sha384(final String data) {
579        return sha384(StringUtils.getBytesUtf8(data));
580    }
581
582    /**
583     * Calculates the SHA-384 digest and returns the value as a hex string.
584     * <p>
585     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
586     * </p>
587     *
588     * @param data
589     *            Data to digest
590     * @return SHA-384 digest as a hex string
591     * @since 1.4
592     */
593    public static String sha384Hex(final byte[] data) {
594        return Hex.encodeHexString(sha384(data));
595    }
596
597    /**
598     * Calculates the SHA-384 digest and returns the value as a hex string.
599     * <p>
600     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
601     * </p>
602     *
603     * @param data
604     *            Data to digest
605     * @return SHA-384 digest as a hex string
606     * @throws IOException
607     *             On error reading from the stream
608     * @since 1.4
609     */
610    public static String sha384Hex(final InputStream data) throws IOException {
611        return Hex.encodeHexString(sha384(data));
612    }
613
614    /**
615     * Calculates the SHA-384 digest and returns the value as a hex string.
616     * <p>
617     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
618     * </p>
619     *
620     * @param data
621     *            Data to digest
622     * @return SHA-384 digest as a hex string
623     * @since 1.4
624     */
625    public static String sha384Hex(final String data) {
626        return Hex.encodeHexString(sha384(data));
627    }
628
629    /**
630     * Calculates the SHA-512 digest and returns the value as a <code>byte[]</code>.
631     * <p>
632     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
633     * </p>
634     *
635     * @param data
636     *            Data to digest
637     * @return SHA-512 digest
638     * @since 1.4
639     */
640    public static byte[] sha512(final byte[] data) {
641        return getSha512Digest().digest(data);
642    }
643
644    /**
645     * Calculates the SHA-512 digest and returns the value as a <code>byte[]</code>.
646     * <p>
647     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
648     * </p>
649     *
650     * @param data
651     *            Data to digest
652     * @return SHA-512 digest
653     * @throws IOException
654     *             On error reading from the stream
655     * @since 1.4
656     */
657    public static byte[] sha512(final InputStream data) throws IOException {
658        return digest(getSha512Digest(), data);
659    }
660
661    /**
662     * Calculates the SHA-512 digest and returns the value as a <code>byte[]</code>.
663     * <p>
664     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
665     * </p>
666     *
667     * @param data
668     *            Data to digest; converted to bytes using {@link StringUtils#getBytesUtf8(String)}
669     * @return SHA-512 digest
670     * @since 1.4
671     */
672    public static byte[] sha512(final String data) {
673        return sha512(StringUtils.getBytesUtf8(data));
674    }
675
676    /**
677     * Calculates the SHA-512 digest and returns the value as a hex string.
678     * <p>
679     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
680     * </p>
681     *
682     * @param data
683     *            Data to digest
684     * @return SHA-512 digest as a hex string
685     * @since 1.4
686     */
687    public static String sha512Hex(final byte[] data) {
688        return Hex.encodeHexString(sha512(data));
689    }
690
691    /**
692     * Calculates the SHA-512 digest and returns the value as a hex string.
693     * <p>
694     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
695     * </p>
696     *
697     * @param data
698     *            Data to digest
699     * @return SHA-512 digest as a hex string
700     * @throws IOException
701     *             On error reading from the stream
702     * @since 1.4
703     */
704    public static String sha512Hex(final InputStream data) throws IOException {
705        return Hex.encodeHexString(sha512(data));
706    }
707
708    /**
709     * Calculates the SHA-512 digest and returns the value as a hex string.
710     * <p>
711     * Throws a <code>RuntimeException</code> on JRE versions prior to 1.4.0.
712     * </p>
713     *
714     * @param data
715     *            Data to digest
716     * @return SHA-512 digest as a hex string
717     * @since 1.4
718     */
719    public static String sha512Hex(final String data) {
720        return Hex.encodeHexString(sha512(data));
721    }
722
723    /**
724     * Calculates the SHA-1 digest and returns the value as a hex string.
725     *
726     * @param data
727     *            Data to digest
728     * @return SHA-1 digest as a hex string
729     * @deprecated Use {@link #sha1Hex(byte[])}
730     */
731    @Deprecated
732    public static String shaHex(final byte[] data) {
733        return sha1Hex(data);
734    }
735
736    /**
737     * Calculates the SHA-1 digest and returns the value as a hex string.
738     *
739     * @param data
740     *            Data to digest
741     * @return SHA-1 digest as a hex string
742     * @throws IOException
743     *             On error reading from the stream
744     * @since 1.4
745     * @deprecated Use {@link #sha1Hex(InputStream)}
746     */
747    @Deprecated
748    public static String shaHex(final InputStream data) throws IOException {
749        return sha1Hex(data);
750    }
751
752    /**
753     * Calculates the SHA-1 digest and returns the value as a hex string.
754     *
755     * @param data
756     *            Data to digest
757     * @return SHA-1 digest as a hex string
758     * @deprecated Use {@link #sha1Hex(String)}
759     */
760    @Deprecated
761    public static String shaHex(final String data) {
762        return sha1Hex(data);
763    }
764
765    /**
766     * Updates the given {@link MessageDigest}.
767     *
768     * @param messageDigest
769     *            the {@link MessageDigest} to update
770     * @param valueToDigest
771     *            the value to update the {@link MessageDigest} with
772     * @return the updated {@link MessageDigest}
773     * @since 1.7
774     */
775    public static MessageDigest updateDigest(final MessageDigest messageDigest, final byte[] valueToDigest) {
776        messageDigest.update(valueToDigest);
777        return messageDigest;
778    }
779
780    /**
781     * Reads through an InputStream and updates the digest for the data
782     *
783     * @param digest
784     *            The MessageDigest to use (e.g. MD5)
785     * @param data
786     *            Data to digest
787     * @return the digest
788     * @throws IOException
789     *             On error reading from the stream
790     * @since 1.8
791     */
792    public static MessageDigest updateDigest(final MessageDigest digest, final InputStream data) throws IOException {
793        final byte[] buffer = new byte[STREAM_BUFFER_LENGTH];
794        int read = data.read(buffer, 0, STREAM_BUFFER_LENGTH);
795
796        while (read > -1) {
797            digest.update(buffer, 0, read);
798            read = data.read(buffer, 0, STREAM_BUFFER_LENGTH);
799        }
800
801        return digest;
802    }
803
804    /**
805     * Updates the given {@link MessageDigest}.
806     *
807     * @param messageDigest
808     *            the {@link MessageDigest} to update
809     * @param valueToDigest
810     *            the value to update the {@link MessageDigest} with;
811     *            converted to bytes using {@link StringUtils#getBytesUtf8(String)}
812     * @return the updated {@link MessageDigest}
813     * @since 1.7
814     */
815    public static MessageDigest updateDigest(final MessageDigest messageDigest, final String valueToDigest) {
816        messageDigest.update(StringUtils.getBytesUtf8(valueToDigest));
817        return messageDigest;
818    }
819}