jdk-24/test/jdk/javax/crypto/Cipher/ByteBuffersNull.java

/*
 * Copyright (c) 2004, 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.
 *
 * 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.
 */

/**
 * @test
 * @bug 5000980
 * @summary Check NullPointerException for cipherSpi.engineUpdate(x, null)
 */

import javax.crypto.CipherSpi;
import java.security.InvalidKeyException;
import java.security.AlgorithmParameters;
import java.security.InvalidAlgorithmParameterException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.AlgorithmParameterSpec;
import java.security.Key;
import java.security.Security;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.BadPaddingException;
import javax.crypto.ShortBufferException;
import javax.crypto.NoSuchPaddingException;
import java.security.GeneralSecurityException;
import java.nio.ByteBuffer;

public class ByteBuffersNull {

    static final int bufSize = 1024;

    public void testCase010() throws Exception {
        CipherSpiImpl c = new CipherSpiImpl();
        BufferDescr[] inBuffers = getByteBuffersForTest(bufSize);
        int failureCount = 0;

        for (int i = 0; i < inBuffers.length; i++) {
            String key = inBuffers[i].descr;
            ByteBuffer bb = inBuffers[i].buf;

            try {

                c.engineUpdate(bb, null);

                throw new Exception("No Exception?!");
            }  catch (NullPointerException npe) {
                // Expected behaviour - pass
                System.out.println("OK: " + npe);
            }
        }
    }

    // Creates a ByteBuffer with a desired properties
    ByteBuffer getByteBuffer(int capacity, int position,
            boolean limitAt0) {
        ByteBuffer bb = ByteBuffer.allocate(capacity);

        bb.position(position);

        if (limitAt0)
            bb.limit(0);

        return bb;
    }

    BufferDescr[] getByteBuffersForTest(int defaultSize) {
        int caseNum = 4;

        BufferDescr[] buffers = new BufferDescr[caseNum];

        // ByteBuffer with capacity 0
        buffers[0]= new BufferDescr("ByteBuffer with capacity == 0",
            getByteBuffer(0,0,false));

        // ByteBuffer with some space but limit = 0
        buffers[1] = new BufferDescr(
            "ByteBuffer with some capacity but limit == 0",
            getByteBuffer(defaultSize, 0, true));

        // ByteBuffer with some remaining data (limit = capacity)
        buffers[2] = new BufferDescr("ByteBuffer with some data",
            getByteBuffer(defaultSize,0,false));

        // ByteBuffer with some data but position is at the limit
        buffers[3] = new BufferDescr(
            "ByteBuffer with data but position at the limit",
            getByteBuffer(defaultSize, defaultSize,false));

        return buffers;
    }

    public static void main(String argv[]) throws Exception {
        ByteBuffersNull test = new ByteBuffersNull();
        test.testCase010();
    }

    class BufferDescr {
        BufferDescr(String d, ByteBuffer b) {
            descr = d;
            buf = b;
        }

        public String descr;
        public ByteBuffer buf;
    }

    public class CipherSpiImpl extends CipherSpi {

        public CipherSpiImpl() {
            super();
        }

        public void engineSetMode(String mode)
            throws NoSuchAlgorithmException { }

        public void engineSetPadding(String padding)
            throws NoSuchPaddingException { }

        public int engineGetBlockSize() {
            return 0;
        }

        public int engineGetOutputSize(int inputLen) {
            return 0;
        }

        public byte[] engineGetIV() {
            return null;
        }

        public AlgorithmParameters engineGetParameters() {
            return null;
        }

        public void engineInit(int opmode, Key key, SecureRandom random)
            throws InvalidKeyException { }

        public void engineInit(int opmode, Key key,
                               AlgorithmParameterSpec params, SecureRandom random)
            throws InvalidKeyException, InvalidAlgorithmParameterException { }

        public void engineInit(int opmode, Key key, AlgorithmParameters params,
                               SecureRandom random)
            throws InvalidKeyException, InvalidAlgorithmParameterException { }

        public byte[] engineUpdate(byte[] input, int offset, int len) {
            return null;
        }

        public int engineUpdate(byte[] input, int inputOffset, int inputLen,
                                byte[] output, int outputOffset)
            throws ShortBufferException {
            return 0;
        }

        public byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen)
            throws IllegalBlockSizeException, BadPaddingException {
            return null;
        }

        public int engineDoFinal(byte[] input, int inputOffset, int inputLen,
                                 byte[] output, int outputOffset)
            throws ShortBufferException, IllegalBlockSizeException,
            BadPaddingException {
            return 0;
        }

        public byte[] engineWrap(Key key)
            throws IllegalBlockSizeException, InvalidKeyException {
            return super.engineWrap(key);
        }

        public Key engineUnwrap(byte[] wKey, String wKeyAlgorithm,
                                int wKeyType) throws InvalidKeyException,
            NoSuchAlgorithmException {
            return super.engineUnwrap(wKey, wKeyAlgorithm, wKeyType);
        }

        public int engineGetKeySize(Key key) throws InvalidKeyException {
            return super.engineGetKeySize(key);
        }

        public int engineDoFinal(ByteBuffer input, ByteBuffer output)
            throws ShortBufferException, IllegalBlockSizeException,
            BadPaddingException {
            return super.engineDoFinal(input, output);
        }

        public int engineUpdate(ByteBuffer input, ByteBuffer output)
            throws ShortBufferException {
            return super.engineUpdate(input, output);
        }
    }
}