xref: /dalvik/libcore/luni/src/main/java/org/apache/harmony/luni/util/SHAOutputStream.java

/*
 *  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.harmony.luni.util;


import java.io.OutputStream;

/**
 * This class implements the Secure Hash Algorithm, SHA-1. The specification can
 * be found at http://csrc.ncsl.nist.gov/fips/fip180-1.txt
 */
public class SHAOutputStream extends OutputStream implements Cloneable {

    /* Constants as in the specification */

    // K in iterations 0..19, from spec
    private static final int K0_19 = 0x5a827999;

    // K in iterations 20..39, from spec
    private static final int K20_39 = 0x6ed9eba1;

    // K in iterations 40..59, from spec
    private static final int K40_59 = 0x8f1bbcdc;

    // K in iterations 60..79, from spec
    private static final int K60_79 = 0xca62c1d6;

    // H0, from spec
    private static final int H0 = 0x67452301;

    // H1, from spec
    private static final int H1 = 0xefcdab89;

    // H2, from spec
    private static final int H2 = 0x98badcfe;

    // H3, from spec
    private static final int H3 = 0x10325476;

    // H4, from spec
    private static final int H4 = 0xc3d2e1f0;

    private static final int HConstantsSize = 5;

    private static final int HashSizeInBytes = 20;

    // 16 words
    private static final int BlockSizeInBytes = 16 * 4;

    // 80 words
    private static final int WArraySize = 80;

    // 5-word Array. Starts with well-known constants, ends with SHA
    private int[] HConstants;

    // 80-word Array.
    private int[] WArray;

    // 16-word Array. Input bit stream M is divided in chunks of MArray
    private byte[] MArray;

    // Number of bytes of input already processed towards SHA result
    private long bytesProcessed;

    // Number of bytes in WArray not processed yet
    private int bytesToProcess;

    // Optimization, for write
    private byte[] oneByte = new byte[1];

    /**
     * Constructs a new SHAOutputStream.
     */
    public SHAOutputStream() {
        super();
        initialize();
        reset();
    }

    /**
     * Constructs a new MD5OutputStream with the given initial state.
     *
     * @param state The initial state of the output stream. This is what will be
     *        returned by getHash() if write() is never called.
     *
     * @throws IllegalArgumentException if state.length is less than 16.
     */
    public SHAOutputStream(byte[] state) {
        this();

        if (state.length < HashSizeInBytes) {
            throw new IllegalArgumentException();
        }

        for (int i = 0; i < 4; i++) {
            HConstants[i] = 0;
            for (int j = 0; j < 4; j++) {
                HConstants[i] += (state[4 * i + j] & 0xFF) << 8 * (3 - j);
            }
        }
    }

    /**
     * Returns a new instance of the same class as the receiver, whose slots
     * have been filled in with the values in the slots of the receiver.
     * <p>
     * Classes which wish to support cloning must specify that they implement
     * the Cloneable interface, since the native implementation checks for this.
     *
     * @return a complete copy of this object
     * @throws CloneNotSupportedException if the component does not implement
     *         the interface Cloneable
     */
    @Override
    public Object clone() throws CloneNotSupportedException {
        // Calling super takes care of primitive type slots
        SHAOutputStream result = (SHAOutputStream) super.clone();
        result.HConstants = this.HConstants.clone();
        result.WArray = this.WArray.clone();
        result.MArray = this.MArray.clone();
        result.oneByte = this.oneByte.clone();
        return result;
    }

    /**
     * Copies a byte array into the receiver's internal buffer, making the
     * adjustments as necessary and keeping the receiver in a consistent state.
     *
     * @param buffer byte array representation of the bytes
     * @param off offset into the source buffer where to start the copying
     * @param len how many bytes in the source byte array to copy
     *
     */
    private void copyToInternalBuffer(byte[] buffer, int off, int len) {
        int index;
        index = off;
        for (int i = bytesToProcess; i < bytesToProcess + len; i++) {
            MArray[i] = buffer[index];
            index++;
        }
        bytesToProcess = bytesToProcess + len;
    }

    /**
     * Returns an int array (length = 5) with the SHA value of the bytes written
     * to the receiver.
     *
     * @return The 5 ints that form the SHA value of the bytes written to
     *         the receiver
     */
    public int[] getHash() {
        this.padBuffer();
        this.processBuffer();
        int[] result = HConstants.clone();
        // After the user asks for the hash value, the stream is put back to the
        // initial state
        reset();
        return result;
    }

    /**
     * Returns a byte array (length = 20) with the SHA value of the bytes
     * written to the receiver.
     *
     * @return The bytes that form the SHA value of the bytes written to
     *         the receiver
     */
    public byte[] getHashAsBytes() {
        byte[] hash = new byte[HashSizeInBytes];
        this.padBuffer();
        this.processBuffer();

        // We need to return HConstants (modified by the loop) as an array of
        // bytes. A memcopy would be the fastest.
        for (int i = 0; i < (HashSizeInBytes / 4); ++i) {
            hash[i * 4] = (byte) (HConstants[i] >>> 24 & 0xff);
            hash[i * 4 + 1] = (byte) (HConstants[i] >>> 16 & 0xff);
            hash[i * 4 + 2] = (byte) (HConstants[i] >>> 8 & 0xff);
            hash[i * 4 + 3] = (byte) (HConstants[i] & 0xff);
        }
        // After the user asks for the hash value, the stream is put back to the
        // initial state
        reset();
        return hash;
    }

    /**
     * Returns a byte array (length = 20) with the SHA value of the bytes
     * written to the receiver.
     *
     * @return The bytes that form the SHA value of the bytes written to
     *         the receiver
     */
    public byte[] getHashAsBytes(boolean pad) {
        byte[] hash = new byte[HashSizeInBytes];
        if (pad) {
            this.padBuffer();
            this.processBuffer();
        }

        // Convert HConstants to an array of bytes
        for (int i = 0; i < (HashSizeInBytes / 4); i++) {
            hash[i * 4] = (byte) (HConstants[i] >>> 24 & 0xff);
            hash[i * 4 + 1] = (byte) (HConstants[i] >>> 16 & 0xff);
            hash[i * 4 + 2] = (byte) (HConstants[i] >>> 8 & 0xff);
            hash[i * 4 + 3] = (byte) (HConstants[i] & 0xff);
        }
        // After the user asks for the hash value, the stream is put back to the
        // initial state
        reset();
        return hash;
    }

    /**
     * Initializes the receiver.
     */
    private void initialize() {
        HConstants = new int[HConstantsSize];
        MArray = new byte[BlockSizeInBytes];
        WArray = new int[WArraySize];
    }

    /**
     * Adds extra bytes to the bit stream as required (see the SHA
     * specification).
     */
    private void padBuffer() {
        long lengthInBits;
        MArray[bytesToProcess] = (byte) 0x80;
        for (int i = bytesToProcess + 1; i < BlockSizeInBytes; i++) {
            MArray[i] = (byte) 0;
        }
        // Get length now because there might be extra padding (length in bits)
        lengthInBits = (bytesToProcess + bytesProcessed) * 8;

        // 9 extra bytes are needed: 1 for 1000... and 8 for length (long)
        if ((bytesToProcess + 9) > BlockSizeInBytes) {
            // Not enough space to append length. We need another block for
            // padding
            // Padding in this buffer only includes 1000000....
            this.processBuffer();
            // Now put 0's in all the buffer. memfill would be faster
            for (int i = 0; i < BlockSizeInBytes; i++) {
                MArray[i] = (byte) 0;
            }
        }

        for (int i = 1; i < 9; i++) {
            MArray[BlockSizeInBytes - i] = (byte) (lengthInBits & 0xff);
            lengthInBits = lengthInBits >>> 8;
        }
    }

    /**
     * Core SHA code. Processes the receiver's buffer of bits, computing the
     * values towards the final SHA
     */
    private void processBuffer() {
        int A; // A variable, from spec
        int B; // B variable, from spec
        int C; // C variable, from spec
        int D; // D variable, from spec
        int E; // E variable, from spec
        int temp; // TEMP, from spec
        int t; // t, for iteration, from spec

        for (t = 0; t <= 15; t++) { // step a, page 7 of spec. Here we convert 4
            // bytes into 1 word, 16 times
            WArray[t] = (MArray[4 * t] & 0xff) << 24
                    | ((MArray[4 * t + 1] & 0xff) << 16)
                    | ((MArray[4 * t + 2] & 0xff) << 8)
                    | (MArray[4 * t + 3] & 0xff);
        }
        for (t = 16; t <= 79; t++) { // step b, page 7 of spec
            temp = (WArray[t - 3] ^ WArray[t - 8] ^ WArray[t - 14] ^ WArray[t - 16]);
            temp = (temp << 1) | (temp >>> (32 - 1)); // element , Circular
            // Shift Left by 1
            WArray[t] = temp;
        }

        // step c, page 7 of spec
        A = HConstants[0];
        B = HConstants[1];
        C = HConstants[2];
        D = HConstants[3];
        E = HConstants[4];

        // step d, page 8 of spec
        for (t = 0; t <= 19; t++) {
            temp = (A << 5) | (A >>> (32 - 5)); // A , Circular Shift Left by 5
            temp = temp + E + WArray[t] + K0_19;
            temp = temp + ((B & C) | (~B & D));
            E = D;
            D = C;
            C = (B << 30) | (B >>> (32 - 30)); // B , Circular Shift Left by 30
            B = A;
            A = temp;
        }
        for (t = 20; t <= 39; t++) {
            temp = (A << 5) | (A >>> (32 - 5)); // A , Circular Shift Left by 5
            temp = temp + E + WArray[t] + K20_39;
            temp = temp + (B ^ C ^ D);
            E = D;
            D = C;
            C = (B << 30) | (B >>> (32 - 30)); // B , Circular Shift Left by 30
            B = A;
            A = temp;
        }
        for (t = 40; t <= 59; t++) {
            temp = (A << 5) | (A >>> (32 - 5)); // A , Circular Shift Left by 5
            temp = temp + E + WArray[t] + K40_59;
            temp = temp + ((B & C) | (B & D) | (C & D));
            E = D;
            D = C;
            C = (B << 30) | (B >>> (32 - 30)); // B , Circular Shift Left by 30
            B = A;
            A = temp;
        }
        for (t = 60; t <= 79; t++) {
            temp = (A << 5) | (A >>> (32 - 5)); // A , Circular Shift Left by 5
            temp = temp + E + WArray[t] + K60_79;
            temp = temp + (B ^ C ^ D);
            E = D;
            D = C;
            C = (B << 30) | (B >>> (32 - 30)); // B , Circular Shift Left by 30
            B = A;
            A = temp;
        }

        // step e, page 8 of spec
        HConstants[0] = HConstants[0] + A;
        HConstants[1] = HConstants[1] + B;
        HConstants[2] = HConstants[2] + C;
        HConstants[3] = HConstants[3] + D;
        HConstants[4] = HConstants[4] + E;
        // Update number of bytes actually processed
        bytesProcessed = bytesProcessed + BlockSizeInBytes;
        bytesToProcess = 0; // No pending bytes in the block

    }

    /**
     * Reset this SHAOutputStream to the state it was before any byte was
     * written to it.
     */
    public void reset() {
        HConstants[0] = H0;
        HConstants[1] = H1;
        HConstants[2] = H2;
        HConstants[3] = H3;
        HConstants[4] = H4;
        bytesProcessed = 0;
        bytesToProcess = 0;
    }

    @Override
    public String toString() {
        return this.getClass().getName() + ':' + toStringBlock(getHashAsBytes());
    }

    /**
     * Converts a block to a String representation.
     *
     * @param block
     *            byte array representation of the bytes
     */
    private static String toStringBlock(byte[] block) {
        return toStringBlock(block, 0, block.length);
    }

    /**
     * Converts a block to a String representation.
     *
     * @param block
     *            byte array representation of the bytes
     * @param off
     *            offset into the block where to start the conversion
     * @param len
     *            how many bytes in the byte array to convert to a printable
     *            representation
     */
    private static String toStringBlock(byte[] block, int off, int len) {
        String hexdigits = "0123456789ABCDEF";
        StringBuilder buf = new StringBuilder();
        buf.append('[');
        for (int i = off; i < off + len; ++i) {
            buf.append(hexdigits.charAt((block[i] >>> 4) & 0xf));
            buf.append(hexdigits.charAt(block[i] & 0xf));
        }
        buf.append(']');
        return buf.toString();
    }

    /**
     * Writes <code>len</code> <code>bytes</code> from this byte array
     * <code>buffer</code> starting at offset <code>off</code> to the
     * SHAOutputStream. The internal buffer used to compute SHA is updated, and
     * the incremental computation of SHA is also performed.
     *
     * @param buffer
     *            the buffer to be written
     * @param off
     *            offset in buffer to get bytes
     * @param len
     *            number of bytes in buffer to write
     */
    @Override
    public void write(byte[] buffer, int off, int len) {
        int spaceLeft;
        int start;
        int bytesLeft;
        spaceLeft = BlockSizeInBytes - bytesToProcess;
        if (len < spaceLeft) { // Extra bytes are not enough to fill buffer
            this.copyToInternalBuffer(buffer, off, len);
            return;
        }
        // Extra bytes are bigger than space in buffer. Process buffer multiple
        // times
        this.copyToInternalBuffer(buffer, off, spaceLeft);
        bytesLeft = len - spaceLeft;
        this.processBuffer();
        start = off + spaceLeft;
        while (bytesLeft >= BlockSizeInBytes) {
            this.copyToInternalBuffer(buffer, start, BlockSizeInBytes);
            bytesLeft = bytesLeft - BlockSizeInBytes;
            this.processBuffer();
            start = start + BlockSizeInBytes;
        }
        if (bytesLeft > 0) {
            // Extra bytes at the end, not enough to fill buffer
            this.copyToInternalBuffer(buffer, start, bytesLeft);
        }
    }

    /**
     * Writes the specified byte <code>b</code> to this OutputStream. Only the
     * low order byte of <code>b</code> is written.
     *
     * @param b
     *            the byte to be written
     */
    @Override
    public void write(int b) {
        // Not thread-safe because we use a shared one-byte buffer
        oneByte[0] = (byte) b;
        write(oneByte, 0, 1);
    }
}