* Copyright (c) 1996, 2018, Oracle and/or its affiliates. All rights reserved.

import java.io.ByteArrayOutputStream;

import java.io.Closeable;

import java.io.IOException;

import java.io.OutputStream;

import java.nio.ByteBuffer;

import sun.security.ssl.SSLCipher.SSLWriteCipher;

 * {@code OutputRecord} takes care of the management of SSL/(D)TLS

 * output records, including buffering, encryption, handshake

 * messages marshal, etc.

abstract class OutputRecord

        extends ByteArrayOutputStream implements Record, Closeable {

    SSLWriteCipher              writeCipher;

    // Needed for KeyUpdate

    TransportContext            tc;

    final HandshakeHash         handshakeHash;

    private static final int[] V3toV2CipherMap1 =

    private static final int[] V3toV2CipherMap3 =

    OutputRecord(HandshakeHash handshakeHash, SSLWriteCipher writeCipher) {

        this.writeCipher = writeCipher;

        this.handshakeHash = handshakeHash;

        return (writeCipher.authenticator != null) &&

                        writeCipher.authenticator.seqNumIsHuge();

    Ciphertext encode(

        ByteBuffer[] srcs, int srcsOffset, int srcsLength,

        ByteBuffer[] dsts, int dstsOffset, int dstsLength) throws IOException {

    void deliver(

            byte[] source, int offset, int length) throws IOException {

    void changeWriteCiphers(SSLWriteCipher writeCipher,

            boolean useChangeCipherSpec) throws IOException {

        if (useChangeCipherSpec) {

            encodeChangeCipherSpec();

        }

    void finishHandshake() {

        // blank

    }

    // apply to DTLS SSLEngine

    synchronized boolean isClosed() {

        return isClosed;

    }

    static long encrypt(

            SSLWriteCipher encCipher, byte contentType, ByteBuffer destination,

            ProtocolVersion protocolVersion) {

        boolean isDTLS = protocolVersion.isDTLS;

            if (protocolVersion.useTLS13PlusSpec()) {

                return d13Encrypt(encCipher,

                        contentType, destination, headerOffset,

                        dstLim, headerSize, protocolVersion);

            } else {

                return d10Encrypt(encCipher,

                        contentType, destination, headerOffset,

                        dstLim, headerSize, protocolVersion);

            }

        } else {

            if (protocolVersion.useTLS13PlusSpec()) {

                return t13Encrypt(encCipher,

                        contentType, destination, headerOffset,

                        dstLim, headerSize, protocolVersion);

            } else {

                return t10Encrypt(encCipher,

                        contentType, destination, headerOffset,

                        dstLim, headerSize, protocolVersion);

    }

    static long d13Encrypt(

            SSLWriteCipher encCipher, byte contentType, ByteBuffer destination,

            int headerOffset, int dstLim, int headerSize,

            ProtocolVersion protocolVersion) {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    private static long d10Encrypt(

            SSLWriteCipher encCipher, byte contentType, ByteBuffer destination,

            int headerOffset, int dstLim, int headerSize,

            ProtocolVersion protocolVersion) {

        byte[] sequenceNumber = encCipher.authenticator.sequenceNumber();

        encCipher.encrypt(contentType, destination);

        // epoch and sequence_number

        destination.put(headerOffset + 3, sequenceNumber[0]);

        destination.put(headerOffset + 4, sequenceNumber[1]);

        destination.put(headerOffset + 5, sequenceNumber[2]);

        destination.put(headerOffset + 6, sequenceNumber[3]);

        destination.put(headerOffset + 7, sequenceNumber[4]);

        destination.put(headerOffset + 8, sequenceNumber[5]);

        destination.put(headerOffset + 9, sequenceNumber[6]);

        destination.put(headerOffset + 10, sequenceNumber[7]);

        // fragment length

        destination.put(headerOffset + 11, (byte)(fragLen >> 8));

        destination.put(headerOffset + 12, (byte)fragLen);

        // Update destination position to reflect the amount of data produced.

        destination.position(destination.limit());

        return Authenticator.toLong(sequenceNumber);

    }

    static long t13Encrypt(

            SSLWriteCipher encCipher, byte contentType, ByteBuffer destination,

            int headerOffset, int dstLim, int headerSize,

            ProtocolVersion protocolVersion) {

        if (!encCipher.isNullCipher()) {

            // inner plaintext, using zero length padding.

            int pos = destination.position();

            destination.position(destination.limit());

            destination.limit(destination.limit() + 1);

            destination.put(contentType);

            destination.position(pos);

        }

        // use the right TLSCiphertext.opaque_type and legacy_record_version

        ProtocolVersion pv = protocolVersion;

        if (!encCipher.isNullCipher()) {

            pv = ProtocolVersion.TLS12;

            contentType = ContentType.APPLICATION_DATA.id;

        } else if (protocolVersion.useTLS13PlusSpec()) {

            pv = ProtocolVersion.TLS12;

        }

        byte[] sequenceNumber = encCipher.authenticator.sequenceNumber();

        encCipher.encrypt(contentType, destination);

        // Finish out the record header.

        int fragLen = destination.limit() - headerOffset - headerSize;

        destination.put(headerOffset, contentType);

        destination.put(headerOffset + 1, pv.major);

        destination.put(headerOffset + 2, pv.minor);

        // fragment length

        destination.put(headerOffset + 3, (byte)(fragLen >> 8));

        destination.put(headerOffset + 4, (byte)fragLen);

        // Update destination position to reflect the amount of data produced.

        destination.position(destination.limit());

        return Authenticator.toLong(sequenceNumber);

    }

    static long t10Encrypt(

            SSLWriteCipher encCipher, byte contentType, ByteBuffer destination,

            int headerOffset, int dstLim, int headerSize,

            ProtocolVersion protocolVersion) {

        byte[] sequenceNumber = encCipher.authenticator.sequenceNumber();

        encCipher.encrypt(contentType, destination);

        // Finish out the record header.

        int fragLen = destination.limit() - headerOffset - headerSize;

        destination.put(headerOffset, contentType);         // content type

        destination.put(headerOffset + 1, protocolVersion.major);

        destination.put(headerOffset + 2, protocolVersion.minor);

        // fragment length

        destination.put(headerOffset + 3, (byte)(fragLen >> 8));

        destination.put(headerOffset + 4, (byte)fragLen);

    long encrypt(

            SSLWriteCipher encCipher, byte contentType, int headerSize) {

        if (protocolVersion.useTLS13PlusSpec()) {

            return t13Encrypt(encCipher, contentType, headerSize);

        } else {

            return t10Encrypt(encCipher, contentType, headerSize);

        }

    }

    private static final class T13PaddingHolder {

        private static final byte[] zeros = new byte[16];

    }

    long t13Encrypt(

            SSLWriteCipher encCipher, byte contentType, int headerSize) {

        if (!encCipher.isNullCipher()) {

            // inner plaintext

            write(contentType);

            write(T13PaddingHolder.zeros, 0, T13PaddingHolder.zeros.length);

        }

        byte[] sequenceNumber = encCipher.authenticator.sequenceNumber();

        int position = headerSize;

        int contentLen = count - position;

        // ensure the capacity

        int packetSize = encCipher.calculatePacketSize(contentLen, headerSize);

        if (packetSize > buf.length) {

            byte[] newBuf = new byte[packetSize];

            System.arraycopy(buf, 0, newBuf, 0, count);

            buf = newBuf;

        // use the right TLSCiphertext.opaque_type and legacy_record_version

        ProtocolVersion pv = protocolVersion;

            pv = ProtocolVersion.TLS12;

            contentType = ContentType.APPLICATION_DATA.id;

        } else {

            pv = ProtocolVersion.TLS12;

        }

        ByteBuffer destination = ByteBuffer.wrap(buf, position, contentLen);

        count = headerSize + encCipher.encrypt(contentType, destination);

        // Fill out the header, write it and the message.

        int fragLen = count - headerSize;

        buf[0] = contentType;

        buf[1] = pv.major;

        buf[2] = pv.minor;

        buf[3] = (byte)((fragLen >> 8) & 0xFF);

        buf[4] = (byte)(fragLen & 0xFF);

        return Authenticator.toLong(sequenceNumber);

    }

    long t10Encrypt(

            SSLWriteCipher encCipher, byte contentType, int headerSize) {

        byte[] sequenceNumber = encCipher.authenticator.sequenceNumber();

        int position = headerSize + writeCipher.getExplicitNonceSize();

        int contentLen = count - position;

        // ensure the capacity

        int packetSize = encCipher.calculatePacketSize(contentLen, headerSize);

        if (packetSize > buf.length) {

            byte[] newBuf = new byte[packetSize];

            System.arraycopy(buf, 0, newBuf, 0, count);

            buf = newBuf;

        ByteBuffer destination = ByteBuffer.wrap(buf, position, contentLen);

        count = headerSize + encCipher.encrypt(contentType, destination);

        return Authenticator.toLong(sequenceNumber);