/*

  * 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.shiro.crypto.hash;

 import org.apache.shiro.codec.Base64;

 import org.apache.shiro.codec.CodecException;

 import org.apache.shiro.codec.Hex;

 import org.apache.shiro.crypto.UnknownAlgorithmException;

 import org.apache.shiro.util.ByteSource;

 import org.apache.shiro.util.StringUtils;

 import java.security.MessageDigest;

 import java.security.NoSuchAlgorithmException;

 import java.util.Arrays;

 /**

  * A {@code Hash} implementation that allows any {@link java.security.MessageDigest MessageDigest} algorithm name to

  * be used.  This class is a less type-safe variant than the other {@code AbstractHash} subclasses

  * (e.g. {@link Sha512Hash}, etc), but it does allow for any algorithm name to be specified in case the other subclass

  * implementations do not represent an algorithm that you may want to use.

  * <p/>

  * As of Shiro 1.1, this class effectively replaces the (now-deprecated) {@link AbstractHash} class.  It subclasses

  * {@code AbstractHash} only to retain backwards-compatibility.

  *

  * @since 1.1

  */

 public class SimpleHash extends AbstractHash {

     private static final int DEFAULT_ITERATIONS = 1;

     /**

      * The {@link java.security.MessageDigest MessageDigest} algorithm name to use when performing the hash.

      */

     private final String algorithmName;

     /**

      * The hashed data

      */

     private byte[] bytes;

     /**

      * Supplied salt, if any.

      */

     private ByteSource salt;

     /**

      * Number of hash iterations to perform.  Defaults to 1 in the constructor.

      */

     private int iterations;

     /**

      * Cached value of the {@link #toHex() toHex()} call so multiple calls won't incur repeated overhead.

      */

     private transient String hexEncoded = null;

     /**

      * Cached value of the {@link #toBase64() toBase64()} call so multiple calls won't incur repeated overhead.

      */

     private transient String base64Encoded = null;

     /**

      * Creates an new instance with only its {@code algorithmName} set - no hashing is performed.

      * <p/>

      * Because all other constructors in this class hash the {@code source} constructor argument, this

      * constructor is useful in scenarios when you have a byte array that you know is already hashed and

      * just want to set the bytes in their raw form directly on an instance.  After using this constructor,

      * you can then immediately call {@link #setBytes setBytes} to have a fully-initialized instance.

      * <p/>

      * <b>N.B.</b>The algorithm identified by the {@code algorithmName} parameter must be available on the JVM.  If it

      * is not, a {@link UnknownAlgorithmException} will be thrown when the hash is performed (not at instantiation).

      *

      * @param algorithmName the {@link java.security.MessageDigest MessageDigest} algorithm name to use when

      *                      performing the hash.

      * @see UnknownAlgorithmException

      */

     public SimpleHash(String algorithmName) {

         this.algorithmName = algorithmName;

         this.iterations = DEFAULT_ITERATIONS;

     }

     /**

      * Creates an {@code algorithmName}-specific hash of the specified {@code source} with no {@code salt} using a

      * single hash iteration.

      * <p/>

      * This is a convenience constructor that merely executes <code>this( algorithmName, source, null, 1);</code>.

      * <p/>

      * Please see the

      * {@link #SimpleHash(String algorithmName, Object source, Object salt, int numIterations) SimpleHashHash(algorithmName, Object,Object,int)}

      * constructor for the types of Objects that may be passed into this constructor, as well as how to support further

      * types.

      *

      * @param algorithmName the {@link java.security.MessageDigest MessageDigest} algorithm name to use when

      *                      performing the hash.

      * @param source        the object to be hashed.

      * @throws org.apache.shiro.codec.CodecException

      *                                   if the specified {@code source} cannot be converted into a byte array (byte[]).

      * @throws UnknownAlgorithmException if the {@code algorithmName} is not available.

      */

     public SimpleHash(String algorithmName, Object source) throws CodecException, UnknownAlgorithmException {

         //noinspection NullableProblems

         this(algorithmName, source, null, DEFAULT_ITERATIONS);

     }

     /**

      * Creates an {@code algorithmName}-specific hash of the specified {@code source} using the given {@code salt}

      * using a single hash iteration.

      * <p/>

      * It is a convenience constructor that merely executes <code>this( algorithmName, source, salt, 1);</code>.

      * <p/>

      * Please see the

      * {@link #SimpleHash(String algorithmName, Object source, Object salt, int numIterations) SimpleHashHash(algorithmName, Object,Object,int)}

      * constructor for the types of Objects that may be passed into this constructor, as well as how to support further

      * types.

      *

      * @param algorithmName the {@link java.security.MessageDigest MessageDigest} algorithm name to use when

      *                      performing the hash.

      * @param source        the source object to be hashed.

      * @param salt          the salt to use for the hash

      * @throws CodecException            if either constructor argument cannot be converted into a byte array.

      * @throws UnknownAlgorithmException if the {@code algorithmName} is not available.

      */

     public SimpleHash(String algorithmName, Object source, Object salt) throws CodecException, UnknownAlgorithmException {

         this(algorithmName, source, salt, DEFAULT_ITERATIONS);

     }

     /**

      * Creates an {@code algorithmName}-specific hash of the specified {@code source} using the given

      * {@code salt} a total of {@code hashIterations} times.

      * <p/>

      * By default, this class only supports Object method arguments of

      * type {@code byte[]}, {@code char[]}, {@link String}, {@link java.io.File File},

      * {@link java.io.InputStream InputStream} or {@link org.apache.shiro.util.ByteSource ByteSource}.  If either

      * argument is anything other than these types a {@link org.apache.shiro.codec.CodecException CodecException}

      * will be thrown.

      * <p/>

      * If you want to be able to hash other object types, or use other salt types, you need to override the

      * {@link #toBytes(Object) toBytes(Object)} method to support those specific types.  Your other option is to

      * convert your arguments to one of the default supported types first before passing them in to this

      * constructor}.

      *

      * @param algorithmName  the {@link java.security.MessageDigest MessageDigest} algorithm name to use when

      *                       performing the hash.

      * @param source         the source object to be hashed.

      * @param salt           the salt to use for the hash

      * @param hashIterations the number of times the {@code source} argument hashed for attack resiliency.

      * @throws CodecException            if either Object constructor argument cannot be converted into a byte array.

      * @throws UnknownAlgorithmException if the {@code algorithmName} is not available.

      */

     public SimpleHash(String algorithmName, Object source, Object salt, int hashIterations)

             throws CodecException, UnknownAlgorithmException {

         if (!StringUtils.hasText(algorithmName)) {

             throw new NullPointerException("algorithmName argument cannot be null or empty.");

         }

         this.algorithmName = algorithmName;

         this.iterations = Math.max(DEFAULT_ITERATIONS, hashIterations);

         ByteSource saltBytes = null;

         if (salt != null) {

             saltBytes = convertSaltToBytes(salt);

             this.salt = saltBytes;

         }

         ByteSource sourceBytes = convertSourceToBytes(source);

         hash(sourceBytes, saltBytes, hashIterations);

     }

     /**

      * Acquires the specified {@code source} argument's bytes and returns them in the form of a {@code ByteSource} instance.

      * <p/>

      * This implementation merely delegates to the convenience {@link #toByteSource(Object)} method for generic

      * conversion.  Can be overridden by subclasses for source-specific conversion.

      *

      * @param source the source object to be hashed.

      * @return the source's bytes in the form of a {@code ByteSource} instance.

      * @since 1.2

      */

     protected ByteSource convertSourceToBytes(Object source) {

         return toByteSource(source);

     }

     /**

      * Acquires the specified {@code salt} argument's bytes and returns them in the form of a {@code ByteSource} instance.

      * <p/>

      * This implementation merely delegates to the convenience {@link #toByteSource(Object)} method for generic

      * conversion.  Can be overridden by subclasses for salt-specific conversion.

      *

      * @param salt the salt to be use for the hash.

      * @return the salt's bytes in the form of a {@code ByteSource} instance.

      * @since 1.2

      */

     protected ByteSource convertSaltToBytes(Object salt) {

         return toByteSource(salt);

     }

     /**

      * Converts a given object into a {@code ByteSource} instance.  Assumes the object can be converted to bytes.

      *

      * @param o the Object to convert into a {@code ByteSource} instance.

      * @return the {@code ByteSource} representation of the specified object's bytes.

      * @since 1.2

      */

     protected ByteSource toByteSource(Object o) {

         if (o == null) {

             return null;

         }

         if (o instanceof ByteSource) {

             return (ByteSource) o;

         }

         byte[] bytes = toBytes(o);

         return ByteSource.Util.bytes(bytes);

     }

     private void hash(ByteSource source, ByteSource salt, int hashIterations) throws CodecException, UnknownAlgorithmException {

         byte[] saltBytes = salt != null ? salt.getBytes() : null;

         byte[] hashedBytes = hash(source.getBytes(), saltBytes, hashIterations);

         setBytes(hashedBytes);

     }

     /**

      * Returns the {@link java.security.MessageDigest MessageDigest} algorithm name to use when performing the hash.

      *

      * @return the {@link java.security.MessageDigest MessageDigest} algorithm name to use when performing the hash.

      */

     public String getAlgorithmName() {

         return this.algorithmName;

     }

     public ByteSource getSalt() {

         return this.salt;

     }

     public int getIterations() {

         return this.iterations;

     }

     public byte[] getBytes() {

         return this.bytes;

     }

     /**

      * Sets the raw bytes stored by this hash instance.

      * <p/>

      * The bytes are kept in raw form - they will not be hashed/changed.  This is primarily a utility method for

      * constructing a Hash instance when the hashed value is already known.

      *

      * @param alreadyHashedBytes the raw already-hashed bytes to store in this instance.

      */

     public void setBytes(byte[] alreadyHashedBytes) {

         this.bytes = alreadyHashedBytes;

         this.hexEncoded = null;

         this.base64Encoded = null;

     }

     /**

      * Sets the iterations used to previously compute AN ALREADY GENERATED HASH.

      * <p/>

      * This is provided <em>ONLY</em> to reconstitute an already-created Hash instance.  It should ONLY ever be

      * invoked when re-constructing a hash instance from an already-hashed value.

      *

      * @param iterations the number of hash iterations used to previously create the hash/digest.

      * @since 1.2

      */

     public void setIterations(int iterations) {

         this.iterations = Math.max(DEFAULT_ITERATIONS, iterations);

     }

     /**

      * Sets the salt used to previously compute AN ALREADY GENERATED HASH.

      * <p/>

      * This is provided <em>ONLY</em> to reconstitute a Hash instance that has already been computed.  It should ONLY

      * ever be invoked when re-constructing a hash instance from an already-hashed value.

      *

      * @param salt the salt used to previously create the hash/digest.

      * @since 1.2

      */

     public void setSalt(ByteSource salt) {

         this.salt = salt;

     }

     /**

      * Returns the JDK MessageDigest instance to use for executing the hash.

      *

      * @param algorithmName the algorithm to use for the hash, provided by subclasses.

      * @return the MessageDigest object for the specified {@code algorithm}.

      * @throws UnknownAlgorithmException if the specified algorithm name is not available.

      */

     protected MessageDigest getDigest(String algorithmName) throws UnknownAlgorithmException {

         try {

             return MessageDigest.getInstance(algorithmName);

         } catch (NoSuchAlgorithmException e) {

             String msg = "No native '" + algorithmName + "' MessageDigest instance available on the current JVM.";

             throw new UnknownAlgorithmException(msg, e);

         }

     }

     /**

      * Hashes the specified byte array without a salt for a single iteration.

      *

      * @param bytes the bytes to hash.

      * @return the hashed bytes.

      * @throws UnknownAlgorithmException if the configured {@link #getAlgorithmName() algorithmName} is not available.

      */

     protected byte[] hash(byte[] bytes) throws UnknownAlgorithmException {

         return hash(bytes, null, DEFAULT_ITERATIONS);

     }

     /**

      * Hashes the specified byte array using the given {@code salt} for a single iteration.

      *

      * @param bytes the bytes to hash

      * @param salt  the salt to use for the initial hash

      * @return the hashed bytes

      * @throws UnknownAlgorithmException if the configured {@link #getAlgorithmName() algorithmName} is not available.

      */

     protected byte[] hash(byte[] bytes, byte[] salt) throws UnknownAlgorithmException {

         return hash(bytes, salt, DEFAULT_ITERATIONS);

     }

     /**

      * Hashes the specified byte array using the given {@code salt} for the specified number of iterations.

      *

      * @param bytes          the bytes to hash

      * @param salt           the salt to use for the initial hash

      * @param hashIterations the number of times the the {@code bytes} will be hashed (for attack resiliency).

      * @return the hashed bytes.

      * @throws UnknownAlgorithmException if the {@link #getAlgorithmName() algorithmName} is not available.

      */

     protected byte[] hash(byte[] bytes, byte[] salt, int hashIterations) throws UnknownAlgorithmException {

         MessageDigest digest = getDigest(getAlgorithmName());

         if (salt != null) {

             digest.reset();

             digest.update(salt);

         }

         byte[] hashed = digest.digest(bytes);

         int iterations = hashIterations - DEFAULT_ITERATIONS; //already hashed once above

         //iterate remaining number:

         for (int i = 0; i < iterations; i++) {

             digest.reset();

             hashed = digest.digest(hashed);

         }

         return hashed;

     }

     public boolean isEmpty() {

         return this.bytes == null || this.bytes.length == 0;

     }

     /**

      * Returns a hex-encoded string of the underlying {@link #getBytes byte array}.

      * <p/>

      * This implementation caches the resulting hex string so multiple calls to this method remain efficient.

      * However, calling {@link #setBytes setBytes} will null the cached value, forcing it to be recalculated the

      * next time this method is called.

      *

      * @return a hex-encoded string of the underlying {@link #getBytes byte array}.

      */

     public String toHex() {

         if (this.hexEncoded == null) {

             this.hexEncoded = Hex.encodeToString(getBytes());

         }

         return this.hexEncoded;

     }

     /**

      * Returns a Base64-encoded string of the underlying {@link #getBytes byte array}.

      * <p/>

      * This implementation caches the resulting Base64 string so multiple calls to this method remain efficient.

      * However, calling {@link #setBytes setBytes} will null the cached value, forcing it to be recalculated the

      * next time this method is called.

      *

      * @return a Base64-encoded string of the underlying {@link #getBytes byte array}.

      */

     public String toBase64() {

         if (this.base64Encoded == null) {

             //cache result in case this method is called multiple times.

             this.base64Encoded = Base64.encodeToString(getBytes());

         }

         return this.base64Encoded;

     }

     /**

      * Simple implementation that merely returns {@link #toHex() toHex()}.

      *

      * @return the {@link #toHex() toHex()} value.

      */

     public String toString() {

         return toHex();

     }

     /**

      * Returns {@code true} if the specified object is a Hash and its {@link #getBytes byte array} is identical to

      * this Hash's byte array, {@code false} otherwise.

      *

      * @param o the object (Hash) to check for equality.

      * @return {@code true} if the specified object is a Hash and its {@link #getBytes byte array} is identical to

      *         this Hash's byte array, {@code false} otherwise.

      */

     public boolean equals(Object o) {

         if (o instanceof Hash) {

             Hash other = (Hash) o;

             return Arrays.equals(getBytes(), other.getBytes());

         }

         return false;

     }

     /**

      * Simply returns toHex().hashCode();

      *

      * @return toHex().hashCode()

      */

     public int hashCode() {

         if (this.bytes == null || this.bytes.length == 0) {

             return 0;

         }

         return Arrays.hashCode(this.bytes);

     }

 }