/*
 * Copyright (c) 2002, 2007, Oracle and/or its affiliates. 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */


package sun.security.ssl;

import java.security.*;

Abstraction for the SSL/TLS hash of all handshake messages that is
maintained to verify the integrity of the negotiation. Internally,
it consists of an MD5 and an SHA1 digest. They are used in the client
and server finished messages and in certificate verify messages (if sent).
This class transparently deals with cloneable and non-cloneable digests.
/**
 * Abstraction for the SSL/TLS hash of all handshake messages that is
 * maintained to verify the integrity of the negotiation. Internally,
 * it consists of an MD5 and an SHA1 digest. They are used in the client
 * and server finished messages and in certificate verify messages (if sent).
 *
 * This class transparently deals with cloneable and non-cloneable digests.
 *
 */
final class HandshakeHash {

    private final MessageDigest md5, sha;

    
Create a new HandshakeHash. needCertificateVerify indicates whether
a hash for the certificate verify message is required.
/**
     * Create a new HandshakeHash. needCertificateVerify indicates whether
     * a hash for the certificate verify message is required.
     */
    HandshakeHash(boolean needCertificateVerify) {
        // We may rework the code later, but for now we use hard-coded number
        // of clones if the underlying MessageDigests are not cloneable.
        //
        // The number used here is based on the current handshake protocols and
        // implementation.  It may be changed if the handshake processe gets
        // changed in the future, for example adding a new extension that
        // requires handshake hash.  Please be careful about the number of
        // clones if additional handshak hash is required in the future.
        //
        // For the current implementation, the handshake hash is required for
        // the following items:
        //     . CertificateVerify handshake message (optional)
        //     . client Finished handshake message
        //     . server Finished Handshake message
        //     . the extended Master Secret extension [RFC 7627]
        //
        // Note that a late call to server setNeedClientAuth dose not update
        // the number of clones.  We may address the issue later.
        //
        // Note for safe, we allocate one more clone for the current
        // implementation.  We may consider it more carefully in the future
        // for the exactly number or rework the code in a different way.
        int n = needCertificateVerify ? 5 : 4;
        try {
            md5 = CloneableDigest.getDigest("MD5", n);
            sha = CloneableDigest.getDigest("SHA", n);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException
                        ("Algorithm MD5 or SHA not available", e);

        }
    }

    void update(byte b) {
        md5.update(b);
        sha.update(b);
    }

    void update(byte[] b, int offset, int len) {
        md5.update(b, offset, len);
        sha.update(b, offset, len);
    }

    
Reset the remaining digests. Note this does *not* reset the numbe of
digest clones that can be obtained. Digests that have already been
cloned and are gone remain gone.
/**
     * Reset the remaining digests. Note this does *not* reset the numbe of
     * digest clones that can be obtained. Digests that have already been
     * cloned and are gone remain gone.
     */
    void reset() {
        md5.reset();
        sha.reset();
    }

    
Return a new MD5 digest updated with all data hashed so far.
/**
     * Return a new MD5 digest updated with all data hashed so far.
     */
    MessageDigest getMD5Clone() {
        return cloneDigest(md5);
    }

    
Return a new SHA digest updated with all data hashed so far.
/**
     * Return a new SHA digest updated with all data hashed so far.
     */
    MessageDigest getSHAClone() {
        return cloneDigest(sha);
    }

    private static MessageDigest cloneDigest(MessageDigest digest) {
        try {
            return (MessageDigest)digest.clone();
        } catch (CloneNotSupportedException e) {
            // cannot occur for digests generated via CloneableDigest
            throw new RuntimeException("Could not clone digest", e);
        }
    }

}

A wrapper for MessageDigests that simulates cloning of non-cloneable
digests. It uses the standard MessageDigest API and therefore can be used
transparently in place of a regular digest.
Note that we extend the MessageDigest class directly rather than
MessageDigestSpi. This works because MessageDigest was originally designed
this way in the JDK 1.1 days which allows us to avoid creating an internal
provider.
It can be "cloned" a limited number of times, which is specified at
construction time. This is achieved by internally maintaining n digests
in parallel. Consequently, it is only 1/n-th times as fast as the original
digest.
Example:
  MessageDigest md = CloneableDigest.getDigest("SHA", 2);
  md.update(data1);
  MessageDigest md2 = (MessageDigest)md.clone();
  md2.update(data2);
  byte[] d1 = md2.digest(); // digest of data1 || data2
  md.update(data3);
  byte[] d2 = md.digest();  // digest of data1 || data3
This class is not thread safe.
/**
 * A wrapper for MessageDigests that simulates cloning of non-cloneable
 * digests. It uses the standard MessageDigest API and therefore can be used
 * transparently in place of a regular digest.
 *
 * Note that we extend the MessageDigest class directly rather than
 * MessageDigestSpi. This works because MessageDigest was originally designed
 * this way in the JDK 1.1 days which allows us to avoid creating an internal
 * provider.
 *
 * It can be "cloned" a limited number of times, which is specified at
 * construction time. This is achieved by internally maintaining n digests
 * in parallel. Consequently, it is only 1/n-th times as fast as the original
 * digest.
 *
 * Example:
 *   MessageDigest md = CloneableDigest.getDigest("SHA", 2);
 *   md.update(data1);
 *   MessageDigest md2 = (MessageDigest)md.clone();
 *   md2.update(data2);
 *   byte[] d1 = md2.digest(); // digest of data1 || data2
 *   md.update(data3);
 *   byte[] d2 = md.digest();  // digest of data1 || data3
 *
 * This class is not thread safe.
 *
 */
final class CloneableDigest extends MessageDigest implements Cloneable {

    
The individual MessageDigests. Initially, all elements are non-null.
When clone() is called, the non-null element with the maximum index is
returned and the array element set to null.
All non-null element are always in the same state.
/**
     * The individual MessageDigests. Initially, all elements are non-null.
     * When clone() is called, the non-null element with the maximum index is
     * returned and the array element set to null.
     *
     * All non-null element are always in the same state.
     */
    private final MessageDigest[] digests;

    private CloneableDigest(MessageDigest digest, int n, String algorithm)
            throws NoSuchAlgorithmException {
        super(algorithm);
        digests = new MessageDigest[n];
        digests[0] = digest;
        for (int i = 1; i < n; i++) {
            digests[i] = JsseJce.getMessageDigest(algorithm);
        }
    }

    
Return a MessageDigest for the given algorithm that can be cloned the
specified number of times. If the default implementation supports
cloning, it is returned. Otherwise, an instance of this class is
returned.
/**
     * Return a MessageDigest for the given algorithm that can be cloned the
     * specified number of times. If the default implementation supports
     * cloning, it is returned. Otherwise, an instance of this class is
     * returned.
     */
    static MessageDigest getDigest(String algorithm, int n)
            throws NoSuchAlgorithmException {
        MessageDigest digest = JsseJce.getMessageDigest(algorithm);
        try {
            digest.clone();
            // already cloneable, use it
            return digest;
        } catch (CloneNotSupportedException e) {
            return new CloneableDigest(digest, n, algorithm);
        }
    }

    
Check if this object is still usable. If it has already been cloned the
maximum number of times, there are no digests left and this object can no
longer be used.
/**
     * Check if this object is still usable. If it has already been cloned the
     * maximum number of times, there are no digests left and this object can no
     * longer be used.
     */
    private void checkState() {
        // XXX handshaking currently doesn't stop updating hashes...
        // if (digests[0] == null) {
        //     throw new IllegalStateException("no digests left");
        // }
    }

    protected int engineGetDigestLength() {
        checkState();
        return digests[0].getDigestLength();
    }

    protected void engineUpdate(byte b) {
        checkState();
        for (int i = 0; (i < digests.length) && (digests[i] != null); i++) {
            digests[i].update(b);
        }
    }

    protected void engineUpdate(byte[] b, int offset, int len) {
        checkState();
        for (int i = 0; (i < digests.length) && (digests[i] != null); i++) {
            digests[i].update(b, offset, len);
        }
    }

    protected byte[] engineDigest() {
        checkState();
        byte[] digest = digests[0].digest();
        digestReset();
        return digest;
    }

    protected int engineDigest(byte[] buf, int offset, int len)
            throws DigestException {
        checkState();
        int n = digests[0].digest(buf, offset, len);
        digestReset();
        return n;
    }

    
Reset all digests after a digest() call. digests[0] has already been
implicitly reset by the digest() call and does not need to be reset
again.
/**
     * Reset all digests after a digest() call. digests[0] has already been
     * implicitly reset by the digest() call and does not need to be reset
     * again.
     */
    private void digestReset() {
        for (int i = 1; (i < digests.length) && (digests[i] != null); i++) {
            digests[i].reset();
        }
    }

    protected void engineReset() {
        checkState();
        for (int i = 0; (i < digests.length) && (digests[i] != null); i++) {
            digests[i].reset();
        }
    }

    public Object clone() {
        checkState();
        for (int i = digests.length - 1; i >= 0; i--) {
            if (digests[i] != null) {
                MessageDigest digest = digests[i];
                digests[i] = null;
                return digest;
            }
        }
        // cannot occur
        throw new InternalError();
    }

}