You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2014/08/23 00:56:09 UTC
svn commit: r1619949 - in /commons/proper/codec/trunk/src:
main/java/org/apache/commons/codec/binary/
main/java/org/apache/commons/codec/digest/
test/java/org/apache/commons/codec/digest/
Author: ggregory
Date: Fri Aug 22 22:56:08 2014
New Revision: 1619949
URL: http://svn.apache.org/r1619949
Log:
Javadoc 8.
Added:
commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacAlgorithms.java (with props)
commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacUtils.java (with props)
commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/digest/HmacUtilsTest.java (with props)
Modified:
commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/binary/Base32.java
Modified: commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/binary/Base32.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/binary/Base32.java?rev=1619949&r1=1619948&r2=1619949&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/binary/Base32.java (original)
+++ commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/binary/Base32.java Fri Aug 22 22:56:08 2014
@@ -175,7 +175,7 @@ public class Base32 extends BaseNCodec {
* <p>
* When encoding the line length is 0 (no chunking).
* </p>
- * @param useHex if <code>true</code> then use Base32 Hex alphabet
+ * @param useHex if {@code true} then use Base32 Hex alphabet
*/
public Base32(final boolean useHex) {
this(0, null, useHex, PAD_DEFAULT);
@@ -186,7 +186,7 @@ public class Base32 extends BaseNCodec {
* <p>
* When encoding the line length is 0 (no chunking).
* </p>
- * @param useHex if <code>true</code> then use Base32 Hex alphabet
+ * @param useHex if {@code true} then use Base32 Hex alphabet
* @param pad byte used as padding byte.
*/
public Base32(final boolean useHex, final byte pad) {
@@ -246,7 +246,7 @@ public class Base32 extends BaseNCodec {
* @param lineSeparator
* Each line of encoded data will end with this sequence of bytes.
* @param useHex
- * if <code>true</code>, then use Base32 Hex alphabet, otherwise use Base32 alphabet
+ * if {@code true}, then use Base32 Hex alphabet, otherwise use Base32 alphabet
* @throws IllegalArgumentException
* The provided lineSeparator included some Base32 characters. That's not going to work! Or the
* lineLength > 0 and lineSeparator is null.
@@ -271,7 +271,7 @@ public class Base32 extends BaseNCodec {
* @param lineSeparator
* Each line of encoded data will end with this sequence of bytes.
* @param useHex
- * if <code>true</code>, then use Base32 Hex alphabet, otherwise use Base32 alphabet
+ * if {@code true}, then use Base32 Hex alphabet, otherwise use Base32 alphabet
* @param pad byte used as padding byte.
* @throws IllegalArgumentException
* The provided lineSeparator included some Base32 characters. That's not going to work! Or the
@@ -526,11 +526,11 @@ public class Base32 extends BaseNCodec {
}
/**
- * Returns whether or not the <code>octet</code> is in the Base32 alphabet.
+ * Returns whether or not the {@code octet} is in the Base32 alphabet.
*
* @param octet
* The value to test
- * @return <code>true</code> if the value is defined in the the Base32 alphabet <code>false</code> otherwise.
+ * @return {@code true} if the value is defined in the the Base32 alphabet {@code false} otherwise.
*/
@Override
public boolean isInAlphabet(final byte octet) {
Added: commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacAlgorithms.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacAlgorithms.java?rev=1619949&view=auto
==============================================================================
--- commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacAlgorithms.java (added)
+++ commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacAlgorithms.java Fri Aug 22 22:56:08 2014
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.codec.digest;
+
+/**
+ * Standard {@link HmacSHA512} algorithm names from the <cite>Java Cryptography Architecture Standard Algorithm Name
+ * Documentation</cite>.
+ *
+ * <p>
+ * <strong>Note: Not all JCE implementations supports all algorithms in this enum.</strong>
+ * </p>
+ *
+ * @see <a href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/StandardNames.html">Java Cryptography
+ * Architecture Standard Algorithm Name Documentation</a>
+ * @since 1.10
+ * @version $Id$
+ */
+public enum HmacAlgorithms {
+
+ /**
+ * The HmacMD5 Message Authentication Code (MAC) algorithm specified in RFC 2104 and RFC 1321.
+ * <p>
+ * Every implementation of the Java platform is required to support this standard Mac algorithm.
+ * </p>
+ */
+ HMAC_MD5("HmacMD5"),
+
+ /**
+ * The HmacSHA1 Message Authentication Code (MAC) algorithm specified in RFC 2104 and FIPS PUB 180-2.
+ * <p>
+ * Every implementation of the Java platform is required to support this standard Mac algorithm.
+ * </p>
+ */
+ HMAC_SHA_1("HmacSHA1"),
+
+ /**
+ * The HmacSHA256 Message Authentication Code (MAC) algorithm specified in RFC 2104 and FIPS PUB 180-2.
+ * <p>
+ * Every implementation of the Java platform is required to support this standard Mac algorithm.
+ * </p>
+ */
+ HMAC_SHA_256("HmacSHA256"),
+
+ /**
+ * The HmacSHA384 Message Authentication Code (MAC) algorithm specified in RFC 2104 and FIPS PUB 180-2.
+ * <p>
+ * Every implementation of the Java platform is <em>not</em> required to support this Mac algorithm.
+ * </p>
+ */
+ HMAC_SHA_384("HmacSHA384"),
+
+ /**
+ * The HmacSHA512 Message Authentication Code (MAC) algorithm specified in RFC 2104 and FIPS PUB 180-2.
+ * <p>
+ * Every implementation of the Java platform is <em>not</em> required to support this Mac algorithm.
+ * </p>
+ */
+ HMAC_SHA_512("HmacSHA512");
+
+ private final String algorithm;
+
+ private HmacAlgorithms(final String algorithm) {
+ this.algorithm = algorithm;
+ }
+
+ /**
+ * The algorithm name
+ *
+ * @see <a
+ * href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/SunProviders.html#SunJCEProvider">Java
+ * Cryptography Architecture Sun Providers Documentation</a>
+ * @return The algorithm name ("HmacSHA512" for example)
+ */
+ @Override
+ public String toString() {
+ return algorithm;
+ }
+
+}
Propchange: commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacAlgorithms.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacAlgorithms.java
------------------------------------------------------------------------------
svn:keywords = Id
Added: commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacUtils.java?rev=1619949&view=auto
==============================================================================
--- commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacUtils.java (added)
+++ commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacUtils.java Fri Aug 22 22:56:08 2014
@@ -0,0 +1,771 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.commons.codec.digest;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+import org.apache.commons.codec.binary.Hex;
+import org.apache.commons.codec.binary.StringUtils;
+
+/**
+ * Simplifies common {@link javax.crypto.Mac} tasks. This class is immutable and thread-safe.
+ *
+ *
+ * <p>
+ * <strong>Note: Not all JCE implementations supports all algorithms. If not supported, an IllegalArgumentException is
+ * thrown.</strong>
+ * </p>
+ *
+ * @since 1.10
+ * @version $Id$
+ */
+public final class HmacUtils {
+
+ private static final int STREAM_BUFFER_LENGTH = 1024;
+
+ /**
+ * Returns an initialized <code>Mac</code> for the HmacMD5 algorithm.
+ * <p>
+ * Every implementation of the Java platform is required to support this standard Mac algorithm.
+ * </p>
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @return A Mac instance initialized with the given key.
+ * @see Mac#getInstance(String)
+ * @see Mac#init(SecretKeySpec)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static Mac getHmacMd5(final byte[] key) {
+ return getInitializedMac(HmacAlgorithms.HMAC_MD5, key);
+ }
+
+ /**
+ * Returns an initialized <code>Mac</code> for the HmacSHA1 algorithm.
+ * <p>
+ * Every implementation of the Java platform is required to support this standard Mac algorithm.
+ * </p>
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @return A Mac instance initialized with the given key.
+ * @see Mac#getInstance(String)
+ * @see Mac#init(SecretKeySpec)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static Mac getHmacSha1(final byte[] key) {
+ return getInitializedMac(HmacAlgorithms.HMAC_SHA_1, key);
+ }
+
+ /**
+ * Returns an initialized <code>Mac</code> for the HmacSHA256 algorithm.
+ * <p>
+ * Every implementation of the Java platform is required to support this standard Mac algorithm.
+ * </p>
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @return A Mac instance initialized with the given key.
+ * @see Mac#getInstance(String)
+ * @see Mac#init(SecretKeySpec)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static Mac getHmacSha256(final byte[] key) {
+ return getInitializedMac(HmacAlgorithms.HMAC_SHA_256, key);
+ }
+
+ /**
+ * Returns an initialized <code>Mac</code> for the HmacSHA384 algorithm.
+ * <p>
+ * Every implementation of the Java platform is <em>not</em> required to support this Mac algorithm.
+ * </p>
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @return A Mac instance initialized with the given key.
+ * @see Mac#getInstance(String)
+ * @see Mac#init(SecretKeySpec)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static Mac getHmacSha384(final byte[] key) {
+ return getInitializedMac(HmacAlgorithms.HMAC_SHA_384, key);
+ }
+
+ /**
+ * Returns an initialized <code>Mac</code> for the HmacSHA512 algorithm.
+ * <p>
+ * Every implementation of the Java platform is <em>not</em> required to support this Mac algorithm.
+ * </p>
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @return A Mac instance initialized with the given key.
+ * @see Mac#getInstance(String)
+ * @see Mac#init(SecretKeySpec)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static Mac getHmacSha512(final byte[] key) {
+ return getInitializedMac(HmacAlgorithms.HMAC_SHA_512, key);
+ }
+
+ /**
+ * Returns an initialized <code>Mac</code> for the given <code>algorithm</code>.
+ *
+ * @param algorithm
+ * the name of the algorithm requested. See <a href=
+ * "http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA" >Appendix
+ * A in the Java Cryptography Architecture Reference Guide</a> for information about standard algorithm
+ * names.
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @return A Mac instance initialized with the given key.
+ * @see Mac#getInstance(String)
+ * @see Mac#init(SecretKeySpec)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static Mac getInitializedMac(final HmacAlgorithms algorithm, final byte[] key) {
+ return getInitializedMac(algorithm.toString(), key);
+ }
+
+ /**
+ * Returns an initialized <code>Mac</code> for the given <code>algorithm</code>.
+ *
+ * @param algorithm
+ * the name of the algorithm requested. See <a href=
+ * "http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA" >Appendix
+ * A in the Java Cryptography Architecture Reference Guide</a> for information about standard algorithm
+ * names.
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @return A Mac instance initialized with the given key.
+ * @see Mac#getInstance(String)
+ * @see Mac#init(SecretKeySpec)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static Mac getInitializedMac(final String algorithm, final byte[] key) {
+
+ if (key == null) {
+ throw new IllegalArgumentException("Null key");
+ }
+
+ try {
+ final SecretKeySpec keySpec = new SecretKeySpec(key, algorithm);
+ final Mac mac = Mac.getInstance(algorithm);
+ mac.init(keySpec);
+ return mac;
+ } catch (final NoSuchAlgorithmException e) {
+ throw new IllegalArgumentException(e);
+ } catch (final InvalidKeyException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ // hmacMd5
+
+ /**
+ * Returns a HmacMD5 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacMD5 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacMd5(final byte[] key, final byte[] valueToDigest) {
+ try {
+ return getHmacMd5(key).doFinal(valueToDigest);
+ } catch (final IllegalStateException e) {
+ // cannot happen
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Returns a HmacMD5 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacMD5 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacMd5(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return updateHmac(getHmacMd5(key), valueToDigest).doFinal();
+ }
+
+ /**
+ * Returns a HmacMD5 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacMD5 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacMd5(final String key, final String valueToDigest) {
+ return hmacMd5(StringUtils.getBytesUtf8(key), StringUtils.getBytesUtf8(valueToDigest));
+ }
+
+ /**
+ * Returns a HmacMD5 Message Authentication Code (MAC) as a hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacMD5 MAC for the given key and value as a hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacMd5Hex(final byte[] key, final byte[] valueToDigest) {
+ return Hex.encodeHexString(hmacMd5(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacMD5 Message Authentication Code (MAC) as a hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacMD5 MAC for the given key and value as a hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacMd5Hex(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return Hex.encodeHexString(hmacMd5(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacMD5 Message Authentication Code (MAC) as a hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacMD5 MAC for the given key and value as a hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacMd5Hex(final String key, final String valueToDigest) {
+ return Hex.encodeHexString(hmacMd5(key, valueToDigest));
+ }
+
+ // hmacSha1
+
+ /**
+ * Returns a HmacSHA1 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA1 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha1(final byte[] key, final byte[] valueToDigest) {
+ try {
+ return getHmacSha1(key).doFinal(valueToDigest);
+ } catch (final IllegalStateException e) {
+ // cannot happen
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Returns a HmacSHA1 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacSHA1 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha1(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return updateHmac(getHmacSha1(key), valueToDigest).doFinal();
+ }
+
+ /**
+ * Returns a HmacSHA1 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA1 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha1(final String key, final String valueToDigest) {
+ return hmacSha1(StringUtils.getBytesUtf8(key), StringUtils.getBytesUtf8(valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA1 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA1 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha1Hex(final byte[] key, final byte[] valueToDigest) {
+ return Hex.encodeHexString(hmacSha1(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA1 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacSHA1 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha1Hex(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return Hex.encodeHexString(hmacSha1(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA1 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA1 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha1Hex(final String key, final String valueToDigest) {
+ return Hex.encodeHexString(hmacSha1(key, valueToDigest));
+ }
+
+ // hmacSha256
+
+ /**
+ * Returns a HmacSHA256 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA256 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha256(final byte[] key, final byte[] valueToDigest) {
+ try {
+ return getHmacSha256(key).doFinal(valueToDigest);
+ } catch (final IllegalStateException e) {
+ // cannot happen
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Returns a HmacSHA256 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacSHA256 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha256(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return updateHmac(getHmacSha256(key), valueToDigest).doFinal();
+ }
+
+ /**
+ * Returns a HmacSHA256 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA256 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha256(final String key, final String valueToDigest) {
+ return hmacSha256(StringUtils.getBytesUtf8(key), StringUtils.getBytesUtf8(valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA256 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA256 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha256Hex(final byte[] key, final byte[] valueToDigest) {
+ return Hex.encodeHexString(hmacSha256(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA256 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacSHA256 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha256Hex(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return Hex.encodeHexString(hmacSha256(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA256 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA256 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha256Hex(final String key, final String valueToDigest) {
+ return Hex.encodeHexString(hmacSha256(key, valueToDigest));
+ }
+
+ // hmacSha384
+
+ /**
+ * Returns a HmacSHA384 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA384 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha384(final byte[] key, final byte[] valueToDigest) {
+ try {
+ return getHmacSha384(key).doFinal(valueToDigest);
+ } catch (final IllegalStateException e) {
+ // cannot happen
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Returns a HmacSHA384 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacSHA384 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha384(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return updateHmac(getHmacSha384(key), valueToDigest).doFinal();
+ }
+
+ /**
+ * Returns a HmacSHA384 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA384 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha384(final String key, final String valueToDigest) {
+ return hmacSha384(StringUtils.getBytesUtf8(key), StringUtils.getBytesUtf8(valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA384 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA384 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha384Hex(final byte[] key, final byte[] valueToDigest) {
+ return Hex.encodeHexString(hmacSha384(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA384 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacSHA384 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha384Hex(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return Hex.encodeHexString(hmacSha384(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA384 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA384 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha384Hex(final String key, final String valueToDigest) {
+ return Hex.encodeHexString(hmacSha384(key, valueToDigest));
+ }
+
+ // hmacSha512
+
+ /**
+ * Returns a HmacSHA512 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA512 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha512(final byte[] key, final byte[] valueToDigest) {
+ try {
+ return getHmacSha512(key).doFinal(valueToDigest);
+ } catch (final IllegalStateException e) {
+ // cannot happen
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ /**
+ * Returns a HmacSHA512 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacSHA512 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha512(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return updateHmac(getHmacSha512(key), valueToDigest).doFinal();
+ }
+
+ /**
+ * Returns a HmacSHA512 Message Authentication Code (MAC) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA512 MAC for the given key and value
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static byte[] hmacSha512(final String key, final String valueToDigest) {
+ return hmacSha512(StringUtils.getBytesUtf8(key), StringUtils.getBytesUtf8(valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA512 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA512 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha512Hex(final byte[] key, final byte[] valueToDigest) {
+ return Hex.encodeHexString(hmacSha512(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA512 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return HmacSHA512 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha512Hex(final byte[] key, final InputStream valueToDigest) throws IOException {
+ return Hex.encodeHexString(hmacSha512(key, valueToDigest));
+ }
+
+ /**
+ * Returns a HmacSHA512 Message Authentication Code (MAC) as hex string (lowercase) for the given key and value.
+ *
+ * @param key
+ * They key for the keyed digest (must not be null)
+ * @param valueToDigest
+ * The value (data) which should to digest (maybe empty or null)
+ * @return HmacSHA512 MAC for the given key and value as hex string (lowercase)
+ * @throws IllegalArgumentException
+ * when a {@link NoSuchAlgorithmException} is caught or key is null or key is invalid.
+ */
+ public static String hmacSha512Hex(final String key, final String valueToDigest) {
+ return Hex.encodeHexString(hmacSha512(key, valueToDigest));
+ }
+
+ // update
+
+ /**
+ * Updates the given {@link Mac}. This generates a digest for valueToDigest and the key the Mac was initialized
+ *
+ * @param mac
+ * the initialized {@link Mac} to update
+ * @param valueToDigest
+ * the value to update the {@link Mac} with (maybe null or empty)
+ * @return the updated {@link Mac}
+ * @throws IllegalStateException
+ * if the Mac was not initialized
+ * @since 1.x
+ */
+ public static Mac updateHmac(final Mac mac, final byte[] valueToDigest) {
+ mac.reset();
+ mac.update(valueToDigest);
+ return mac;
+ }
+
+ /**
+ * Updates the given {@link Mac}. This generates a digest for valueToDigest and the key the Mac was initialized
+ *
+ * @param mac
+ * the initialized {@link Mac} to update
+ * @param valueToDigest
+ * the value to update the {@link Mac} with
+ * <p>
+ * The InputStream must not be null and will not be closed
+ * </p>
+ * @return the updated {@link Mac}
+ * @throws IllegalStateException
+ * if the Mac was not initialized
+ * @since 1.x
+ */
+ public static Mac updateHmac(final Mac mac, final InputStream valueToDigest) throws IOException {
+ mac.reset();
+ final byte[] buffer = new byte[STREAM_BUFFER_LENGTH];
+ int read = valueToDigest.read(buffer, 0, STREAM_BUFFER_LENGTH);
+
+ while (read > -1) {
+ mac.update(buffer, 0, read);
+ read = valueToDigest.read(buffer, 0, STREAM_BUFFER_LENGTH);
+ }
+
+ return mac;
+ }
+
+ /**
+ * Updates the given {@link Mac}. This generates a digest for valueToDigest and the key the Mac was initialized
+ *
+ * @param mac
+ * the initialized {@link Mac} to update
+ * @param valueToDigest
+ * the value to update the {@link Mac} with (maybe null or empty)
+ * @return the updated {@link Mac}
+ * @throws IllegalStateException
+ * if the Mac was not initialized
+ * @since 1.x
+ */
+ public static Mac updateHmac(final Mac mac, final String valueToDigest) {
+ mac.reset();
+ mac.update(StringUtils.getBytesUtf8(valueToDigest));
+ return mac;
+ }
+}
Propchange: commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacUtils.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/codec/trunk/src/main/java/org/apache/commons/codec/digest/HmacUtils.java
------------------------------------------------------------------------------
svn:keywords = Id
Added: commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/digest/HmacUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/digest/HmacUtilsTest.java?rev=1619949&view=auto
==============================================================================
--- commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/digest/HmacUtilsTest.java (added)
+++ commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/digest/HmacUtilsTest.java Fri Aug 22 22:56:08 2014
@@ -0,0 +1,276 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.codec.digest;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+import org.apache.commons.codec.binary.Hex;
+import org.apache.commons.codec.binary.StringUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Tests HmacUtils methods.
+ *
+ * @version $Id$
+ */
+public class HmacUtilsTest {
+ private static final String STANDARD_KEY_STRING = "key";
+ private static final byte[] STANDARD_KEY_BYTES = STANDARD_KEY_STRING.getBytes();
+ private static final byte[] STANDARD_MD5_RESULT_BYTES = new byte[] { -128, 7, 7, 19, 70, 62, 119, 73, -71, 12, 45,
+ -62, 73, 17, -30, 117 };
+ private static final String STANDARD_MD5_RESULT_STRING = "80070713463e7749b90c2dc24911e275";
+ private static final String STANDARD_PHRASE_STRING = "The quick brown fox jumps over the lazy dog";
+ private static final byte[] STANDARD_PHRASE_BYTES = STANDARD_PHRASE_STRING.getBytes();
+ private static final byte[] STANDARD_SHA1_RESULT_BYTES = new byte[] { -34, 124, -101, -123, -72, -73, -118, -90,
+ -68, -118, 122, 54, -9, 10, -112, 112, 28, -99, -76, -39 };
+ private static final String STANDARD_SHA1_RESULT_STRING = "de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9";
+ private static final byte[] STANDARD_SHA256_RESULT_BYTES = new byte[] { -9, -68, -125, -12, 48, 83, -124, 36, -79,
+ 50, -104, -26, -86, 111, -79, 67, -17, 77, 89, -95, 73, 70, 23, 89, -105, 71, -99, -68, 45, 26, 60, -40 };
+ private static final String STANDARD_SHA256_RESULT_STRING = "f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8";
+ private static final byte[] STANDARD_SHA384_RESULT_BYTES = new byte[] { -41, -12, 114, 126, 44, 11, 57, -82, 15,
+ 30, 64, -52, -106, -10, 2, 66, -43, -73, -128, 24, 65, -50, -90, -4, 89, 44, 93, 62, 26, -27, 7, 0, 88, 42,
+ -106, -49, 53, -31, -27, 84, -103, 95, -28, -32, 51, -127, -62, 55 };
+ private static final String STANDARD_SHA384_RESULT_STRING = "D7F4727E2C0B39AE0F1E40CC96F60242D5B7801841CEA6FC592C5D3E1AE50700582A96CF35E1E554995FE4E03381C237"
+ .toLowerCase();
+ private static final byte[] STANDARD_SHA512_RESULT_BYTES = new byte[] { -76, 42, -16, -112, 87, -70, -63, -30, -44,
+ 23, 8, -28, -118, -112, 46, 9, -75, -1, 127, 18, -85, 66, -118, 79, -24, 102, 83, -57, 61, -46, 72, -5,
+ -126, -7, 72, -91, 73, -9, -73, -111, -91, -76, 25, 21, -18, 77, 30, -61, -109, 83, 87, -28, -30, 49, 114,
+ 80, -48, 55, 42, -6, 46, -66, -21, 58 };
+ private static final String STANDARD_SHA512_RESULT_STRING = "B42AF09057BAC1E2D41708E48A902E09B5FF7F12AB428A4FE86653C73DD248FB82F948A549F7B791A5B41915EE4D1EC3935357E4E2317250D0372AFA2EBEEB3A"
+ .toLowerCase();
+
+ @Test
+ public void testConstructor() {
+ assertNotNull(new HmacUtils());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testEmptyKey() {
+ HmacUtils.getHmacMd5(new byte[] {});
+ }
+
+ @Test
+ public void testGetHMac() throws IOException {
+ Assert.assertArrayEquals(STANDARD_MD5_RESULT_BYTES,
+ HmacUtils.getHmacMd5(STANDARD_KEY_BYTES).doFinal(STANDARD_PHRASE_BYTES));
+ Assert.assertArrayEquals(STANDARD_SHA1_RESULT_BYTES,
+ HmacUtils.getHmacSha1(STANDARD_KEY_BYTES).doFinal(STANDARD_PHRASE_BYTES));
+ Assert.assertArrayEquals(STANDARD_SHA256_RESULT_BYTES,
+ HmacUtils.getHmacSha256(STANDARD_KEY_BYTES).doFinal(STANDARD_PHRASE_BYTES));
+ Assert.assertArrayEquals(STANDARD_SHA384_RESULT_BYTES,
+ HmacUtils.getHmacSha384(STANDARD_KEY_BYTES).doFinal(STANDARD_PHRASE_BYTES));
+ Assert.assertArrayEquals(STANDARD_SHA512_RESULT_BYTES,
+ HmacUtils.getHmacSha512(STANDARD_KEY_BYTES).doFinal(STANDARD_PHRASE_BYTES));
+ }
+
+ @Test
+ public void testHmacMd5Hex() throws IOException {
+ assertEquals("80070713463e7749b90c2dc24911e275",
+ HmacUtils.hmacMd5Hex(STANDARD_KEY_STRING, "The quick brown fox jumps over the lazy dog"));
+ assertEquals("750c783e6ab0b503eaa86e310a5db738", HmacUtils.hmacMd5Hex("Jefe", "what do ya want for nothing?"));
+ assertEquals(
+ "750c783e6ab0b503eaa86e310a5db738",
+ HmacUtils.hmacMd5Hex("Jefe".getBytes(),
+ new ByteArrayInputStream("what do ya want for nothing?".getBytes())));
+ }
+
+ @Test
+ public void testHmacSha1Hex() throws IOException {
+ assertEquals(STANDARD_SHA1_RESULT_STRING, HmacUtils.hmacSha1Hex(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ assertEquals("f42bb0eeb018ebbd4597ae7213711ec60760843f", HmacUtils.hmacSha1Hex(STANDARD_KEY_STRING, ""));
+ assertEquals("effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+ HmacUtils.hmacSha1Hex("Jefe", "what do ya want for nothing?"));
+ assertEquals(
+ "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+ HmacUtils.hmacSha1Hex("Jefe".getBytes(),
+ new ByteArrayInputStream("what do ya want for nothing?".getBytes())));
+ }
+
+ @Test
+ public void testHmacSha1UpdateWithByteArray() throws IOException {
+ final Mac mac = HmacUtils.getHmacSha1(STANDARD_KEY_BYTES);
+ HmacUtils.updateHmac(mac, STANDARD_PHRASE_BYTES);
+ assertEquals(STANDARD_SHA1_RESULT_STRING, Hex.encodeHexString(mac.doFinal()));
+ HmacUtils.updateHmac(mac, "".getBytes());
+ assertEquals("f42bb0eeb018ebbd4597ae7213711ec60760843f", Hex.encodeHexString(mac.doFinal()));
+ }
+
+ @Test
+ public void testHmacSha1UpdateWithInpustream() throws IOException {
+ final Mac mac = HmacUtils.getHmacSha1(STANDARD_KEY_BYTES);
+ HmacUtils.updateHmac(mac, new ByteArrayInputStream(STANDARD_PHRASE_BYTES));
+ assertEquals(STANDARD_SHA1_RESULT_STRING, Hex.encodeHexString(mac.doFinal()));
+ HmacUtils.updateHmac(mac, new ByteArrayInputStream("".getBytes()));
+ assertEquals("f42bb0eeb018ebbd4597ae7213711ec60760843f", Hex.encodeHexString(mac.doFinal()));
+ }
+
+ @Test
+ public void testHmacSha1UpdateWithString() throws IOException {
+ final Mac mac = HmacUtils.getHmacSha1(STANDARD_KEY_BYTES);
+ HmacUtils.updateHmac(mac, STANDARD_PHRASE_STRING);
+ assertEquals(STANDARD_SHA1_RESULT_STRING, Hex.encodeHexString(mac.doFinal()));
+ HmacUtils.updateHmac(mac, "");
+ assertEquals("f42bb0eeb018ebbd4597ae7213711ec60760843f", Hex.encodeHexString(mac.doFinal()));
+ }
+
+ @Test
+ public void testInitializedMac() throws IOException {
+ final Mac md5Mac = HmacUtils.getInitializedMac(HmacAlgorithms.HMAC_MD5, STANDARD_KEY_BYTES);
+ final Mac md5Mac2 = HmacUtils.getInitializedMac("HmacMD5", STANDARD_KEY_BYTES);
+ Assert.assertArrayEquals(STANDARD_MD5_RESULT_BYTES, HmacUtils.updateHmac(md5Mac, STANDARD_PHRASE_STRING)
+ .doFinal());
+ Assert.assertArrayEquals(STANDARD_MD5_RESULT_BYTES, HmacUtils.updateHmac(md5Mac2, STANDARD_PHRASE_STRING)
+ .doFinal());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testInitializedMacNullAlgo() throws IOException {
+ HmacUtils.getInitializedMac((String) null, STANDARD_KEY_BYTES);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testInitializedMacNullKey() throws IOException {
+ HmacUtils.getInitializedMac(HmacAlgorithms.HMAC_MD5, null);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testInternalNoSuchAlgorithmException() {
+ HmacUtils.getInitializedMac("Bogus Bogus", StringUtils.getBytesUtf8("akey"));
+ }
+
+ @Test
+ public void testMd5HMac() throws IOException {
+ Assert.assertArrayEquals(STANDARD_MD5_RESULT_BYTES,
+ HmacUtils.hmacMd5(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertArrayEquals(STANDARD_MD5_RESULT_BYTES,
+ HmacUtils.hmacMd5(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertArrayEquals(STANDARD_MD5_RESULT_BYTES,
+ HmacUtils.hmacMd5(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ Assert.assertEquals(STANDARD_MD5_RESULT_STRING, HmacUtils.hmacMd5Hex(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertEquals(STANDARD_MD5_RESULT_STRING,
+ HmacUtils.hmacMd5Hex(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertEquals(STANDARD_MD5_RESULT_STRING,
+ HmacUtils.hmacMd5Hex(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testMd5HMacFail() throws IOException {
+ HmacUtils.hmacMd5((byte[]) null, STANDARD_PHRASE_BYTES);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testNullKey() {
+ HmacUtils.getHmacMd5(null);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testSecretKeySpecAllowsEmtyKeys() {
+ new SecretKeySpec(new byte[] {}, "HmacMD5");
+ }
+
+ @Test
+ public void testSha1HMac() throws IOException {
+ Assert.assertArrayEquals(STANDARD_SHA1_RESULT_BYTES,
+ HmacUtils.hmacSha1(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertArrayEquals(STANDARD_SHA1_RESULT_BYTES,
+ HmacUtils.hmacSha1(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertArrayEquals(STANDARD_SHA1_RESULT_BYTES,
+ HmacUtils.hmacSha1(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ Assert.assertEquals(STANDARD_SHA1_RESULT_STRING,
+ HmacUtils.hmacSha1Hex(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertEquals(STANDARD_SHA1_RESULT_STRING,
+ HmacUtils.hmacSha1Hex(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertEquals(STANDARD_SHA1_RESULT_STRING,
+ HmacUtils.hmacSha1Hex(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testSha1HMacFail() throws IOException {
+ HmacUtils.hmacSha1((byte[]) null, STANDARD_PHRASE_BYTES);
+ }
+
+ @Test
+ public void testSha256HMac() throws IOException {
+ Assert.assertArrayEquals(STANDARD_SHA256_RESULT_BYTES,
+ HmacUtils.hmacSha256(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertArrayEquals(STANDARD_SHA256_RESULT_BYTES,
+ HmacUtils.hmacSha256(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertArrayEquals(STANDARD_SHA256_RESULT_BYTES,
+ HmacUtils.hmacSha256(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ Assert.assertEquals(STANDARD_SHA256_RESULT_STRING,
+ HmacUtils.hmacSha256Hex(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertEquals(STANDARD_SHA256_RESULT_STRING,
+ HmacUtils.hmacSha256Hex(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertEquals(STANDARD_SHA256_RESULT_STRING,
+ HmacUtils.hmacSha256Hex(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testSha256HMacFail() throws IOException {
+ HmacUtils.hmacSha256((byte[]) null, STANDARD_PHRASE_BYTES);
+ }
+
+ @Test
+ public void testSha384HMac() throws IOException {
+ Assert.assertArrayEquals(STANDARD_SHA384_RESULT_BYTES,
+ HmacUtils.hmacSha384(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertArrayEquals(STANDARD_SHA384_RESULT_BYTES,
+ HmacUtils.hmacSha384(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertArrayEquals(STANDARD_SHA384_RESULT_BYTES,
+ HmacUtils.hmacSha384(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ Assert.assertEquals(STANDARD_SHA384_RESULT_STRING,
+ HmacUtils.hmacSha384Hex(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertEquals(STANDARD_SHA384_RESULT_STRING,
+ HmacUtils.hmacSha384Hex(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertEquals(STANDARD_SHA384_RESULT_STRING,
+ HmacUtils.hmacSha384Hex(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testSha384HMacFail() throws IOException {
+ HmacUtils.hmacSha384((byte[]) null, STANDARD_PHRASE_BYTES);
+ }
+
+ @Test
+ public void testSha512HMac() throws IOException {
+ Assert.assertArrayEquals(STANDARD_SHA512_RESULT_BYTES,
+ HmacUtils.hmacSha512(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertArrayEquals(STANDARD_SHA512_RESULT_BYTES,
+ HmacUtils.hmacSha512(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertArrayEquals(STANDARD_SHA512_RESULT_BYTES,
+ HmacUtils.hmacSha512(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ Assert.assertEquals(STANDARD_SHA512_RESULT_STRING,
+ HmacUtils.hmacSha512Hex(STANDARD_KEY_BYTES, STANDARD_PHRASE_BYTES));
+ Assert.assertEquals(STANDARD_SHA512_RESULT_STRING,
+ HmacUtils.hmacSha512Hex(STANDARD_KEY_BYTES, new ByteArrayInputStream(STANDARD_PHRASE_BYTES)));
+ Assert.assertEquals(STANDARD_SHA512_RESULT_STRING,
+ HmacUtils.hmacSha512Hex(STANDARD_KEY_STRING, STANDARD_PHRASE_STRING));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testSha512HMacFail() throws IOException {
+ HmacUtils.hmacSha512((byte[]) null, STANDARD_PHRASE_BYTES);
+ }
+}
\ No newline at end of file
Propchange: commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/digest/HmacUtilsTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/digest/HmacUtilsTest.java
------------------------------------------------------------------------------
svn:keywords = Id