/*
 * Copyright 2008 - 2009 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

/*
 * This is a combination and adaptation of subsets of
 * <code>java.security.MessageDigest</code> and
 * <code>sun.security.provider.DigestBase</code> to provide a class offering
 * most of the same public methods of <code>MessageDigest</code> while not
 * depending on the Java Security Framework.
 * <p>
 * One algorithm is currently supported: "SHA-1".
 * <p>
 * NOTE If <code>java.security.MessageDigest</code>,
 * <code>sun.security.provider.DigestBase</code> or
 * <code>sun.security.provider.SHA</code> are modified, review of those
 * modifications should be done to determine any possible implications for this
 * class and <code>StandaloneSHA</code>.
 */

package sun.jkernel;

import java.security.DigestException;
import java.security.ProviderException;
import java.security.NoSuchAlgorithmException;

/**
 * (Adapted from the <code>sun.security.provider.DigestBase</code> doc).
 * This is a simple subset of the Common base message digest implementation
 * for the Sun provider.
 * It implements most of the JCA methods as suitable for a Java message
 * digest
 * implementation of an algorithm based on a compression function (as all
 * commonly used algorithms are). The individual digest subclasses only need to
 * implement the following methods:
 *
 *  . abstract void implCompress(byte[] b, int ofs);
 *  . abstract void implDigest(byte[] out, int ofs);
 *  . abstract void implReset();
 * <p>
 * No support for a clone() method is provided.
 * <p>
 * See the inline documentation for details.
 *
 * @since   1.5
 * @version 1.3, 08/08/07
 * @author  Andreas Sterbenz (MessageDigest)
 * @author  Pete Soper (this derived class)
 */
public abstract class StandaloneMessageDigest {

     public static final boolean debug = false;

    /*
     * (Copied/adapted from <code>java.security.MessageDigest</code>
     *
     * This is a subset/simplification <code>java.security.MessageDigest</code>
     * that supports a fixed set of hashcode mechanisms (currently just
     * SHA-1) while preserving the following MessageDigest methods:
     *
     * public MessageDigest getInstance(String algorithm)
     * public final int getDigestLength()
     * public void reset()
     * public byte[] digest()
     * public void update(byte[] input, int offset, int len)
     * public final String getAlgorithm()
     * <p>
     * NOTE that the clone() method is not provided.
     */

    /**
     * Prevent direct instantiation except via the factory method.
     */

    private StandaloneMessageDigest() {
        // Keep javac happy.
        digestLength = 0;
        blockSize = 0;
        algorithm = null;
        buffer = null;
    }

    private String algorithm;

    // The state of this digest
    private static final int INITIAL = 0;
    private static final int IN_PROGRESS = 1;
    private int state = INITIAL;

    /**
     * Returns a StandaloneMessageDigest object that implements the specified
     * digest algorithm.
     *
     * <p> This method returns a new StandaloneMessageDigest for a single
     * algorithm provider.
     *
     * @param algorithm the name of the algorithm requested.
     *
     * @return a standalone Message Digest object that implements the specified algorithm.
     *
     * @exception NoSuchAlgorithmException if algorithm not supported
     *
     */
    public static StandaloneMessageDigest getInstance(String algorithm)
        throws NoSuchAlgorithmException {
        if (! algorithm.equals("SHA-1")) {
            throw new NoSuchAlgorithmException(algorithm + " not found");
        } else {
            return new StandaloneSHA();
        }
    }

    /**
     * Updates the digest using the specified array of bytes, starting
     * at the specified offset.
     *
     * @param input the array of bytes.
     *
     * @param offset the offset to start from in the array of bytes.
     *
     * @param len the number of bytes to use, starting at
     * <code>offset</code>.
     */
    public void update(byte[] input, int offset, int len) {
        if (debug) {
            System.out.println("StandaloneMessageDigest.update");
            (new Exception()).printStackTrace();
        }
        if (input == null) {
            throw new IllegalArgumentException("No input buffer given");
        }
        if (input.length - offset < len) {
            throw new IllegalArgumentException("Input buffer too short");
        }
        // No need to check for negative offset: engineUpdate does this

        engineUpdate(input, offset, len);
        state = IN_PROGRESS;
    }

    /**
     * Completes the hash computation by performing final operations
     * such as padding. The digest is reset after this call is made.
     *
     * @return the array of bytes for the resulting hash value.
     */
    public byte[] digest() {
        if (debug) {
            System.out.println("StandaloneMessageDigest.digest");
        }
        /* Resetting is the responsibility of implementors. */
        byte[] result = engineDigest();
        state = INITIAL;
        return result;
    }

    /**
     * Compares two digests for equality. Does a simple byte compare.
     *
     * @param digesta one of the digests to compare.
     *
     * @param digestb the other digest to compare.
     *
     * @return true if the digests are equal, false otherwise.
     */
    public static boolean isEqual(byte digesta[], byte digestb[]) {
        if (digesta.length != digestb.length)
            return false;

        for (int i = 0; i < digesta.length; i++) {
            if (digesta[i] != digestb[i]) {
                return false;
            }
        }
        return true;
    }

    /**
     * Resets the digest for further use.
     */
    public void reset() {
        if (debug) {
            System.out.println("StandaloneMessageDigest.reset");
        }
        engineReset();
        state = INITIAL;
    }

    /**
     * Returns a string that identifies the algorithm, independent of
     * implementation details. The name should be a standard
     * Java Security name (such as "SHA", "MD5", and so on).
     * See Appendix A in the <a href=
     * "../../../technotes/guides/security/crypto/CryptoSpec.html#AppA">
     * Java Cryptography Architecture API Specification &amp; Reference </a>
     * for information about standard algorithm names.
     *
     * @return the name of the algorithm
     */
    public final String getAlgorithm() {
        return this.algorithm;
    }

    /**
     * Returns the length of the digest in bytes.
     *
     * @return the digest length in bytes.
     *
     * @since 1.2
     */
    public final int getDigestLength() {
        return engineGetDigestLength();
    }

    //* End of copied/adapted <code>java.security.MessageDigest</code>

    // Start of copied/adapted <code>sun.security.provider.DigestBase</code>

    // one element byte array, temporary storage for update(byte)
    private byte[] oneByte;

    // length of the message digest in bytes
    private final int digestLength;

    // size of the input to the compression function in bytes
    private final int blockSize;
    // buffer to store partial blocks, blockSize bytes large
    // Subclasses should not access this array directly except possibly in their
    // implDigest() method. See MD5.java as an example.
    final byte[] buffer;
    // offset into buffer
    private int bufOfs;

    // number of bytes processed so far. subclasses should not modify
    // this value.
    // also used as a flag to indicate reset status
    // -1: need to call engineReset() before next call to update()
    //  0: is already reset
    long bytesProcessed;

    /**
     * Main constructor.
     */
    StandaloneMessageDigest(String algorithm, int digestLength, int blockSize) {
        // super();
        this.algorithm = algorithm;
        this.digestLength = digestLength;
        this.blockSize = blockSize;
        buffer = new byte[blockSize];
    }

    // return digest length. See JCA doc.
    protected final int engineGetDigestLength() {
        return digestLength;
    }

    // single byte update. See JCA doc.
    protected final void engineUpdate(byte b) {
        if (oneByte == null) {
            oneByte = new byte[1];
        }
        oneByte[0] = b;
        engineUpdate(oneByte, 0, 1);
    }

    // array update. See JCA doc.
    protected final void engineUpdate(byte[] b, int ofs, int len) {
        if (len == 0) {
            return;
        }
        if ((ofs < 0) || (len < 0) || (ofs > b.length - len)) {
            throw new ArrayIndexOutOfBoundsException();
        }
        if (bytesProcessed < 0) {
            engineReset();
        }
        bytesProcessed += len;
        // if buffer is not empty, we need to fill it before proceeding
        if (bufOfs != 0) {
            int n = Math.min(len, blockSize - bufOfs);
            System.arraycopy(b, ofs, buffer, bufOfs, n);
            bufOfs += n;
            ofs += n;
            len -= n;
            if (bufOfs >= blockSize) {
                // compress completed block now
                implCompress(buffer, 0);
                bufOfs = 0;
            }
        }
        // compress complete blocks
        while (len >= blockSize) {
            implCompress(b, ofs);
            len -= blockSize;
            ofs += blockSize;
        }
        // copy remainder to buffer
        if (len > 0) {
            System.arraycopy(b, ofs, buffer, 0, len);
            bufOfs = len;
        }
    }

    // reset this object. See JCA doc.
    protected final void engineReset() {
        if (bytesProcessed == 0) {
            // already reset, ignore
            return;
        }
        implReset();
        bufOfs = 0;
        bytesProcessed = 0;
    }

    // return the digest. See JCA doc.
    protected final byte[] engineDigest() throws ProviderException {
        byte[] b = new byte[digestLength];
        try {
            engineDigest(b, 0, b.length);
        } catch (DigestException e) {
            throw (ProviderException)
                new ProviderException("Internal error").initCause(e);
        }
        return b;
    }

    // return the digest in the specified array. See JCA doc.
    protected final int engineDigest(byte[] out, int ofs, int len)
            throws DigestException {
        if (len < digestLength) {
            throw new DigestException("Length must be at least "
                + digestLength + " for " + algorithm + "digests");
        }
        if ((ofs < 0) || (len < 0) || (ofs > out.length - len)) {
            throw new DigestException("Buffer too short to store digest");
        }
        if (bytesProcessed < 0) {
            engineReset();
        }
        implDigest(out, ofs);
        bytesProcessed = -1;
        return digestLength;
    }

    /**
     * Core compression function. Processes blockSize bytes at a time
     * and updates the state of this object.
     */
    abstract void implCompress(byte[] b, int ofs);

    /**
     * Return the digest. Subclasses do not need to reset() themselves,
     * StandaloneMessageDigest calls implReset() when necessary.
     */
    abstract void implDigest(byte[] out, int ofs);

    /**
     * Reset subclass specific state to their initial values. StandaloneMessageDigest
     * calls this method when necessary.
     */
    abstract void implReset();

    // padding used for the MD5, and SHA-* message digests
    static final byte[] padding;

    static {
        // we need 128 byte padding for SHA-384/512
        // and an additional 8 bytes for the high 8 bytes of the 16
        // byte bit counter in SHA-384/512
        padding = new byte[136];
        padding[0] = (byte)0x80;
    }

}