xref: /openjdk10/jdk/src/jdk.crypto.ucrypto/solaris/classes/com/oracle/security/ucrypto/NativeCipher.java

/*
 * Copyright (c) 2014, 2015, 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 com.oracle.security.ucrypto;

import java.nio.ByteBuffer;
import java.util.Set;
import java.util.Arrays;
import java.util.concurrent.ConcurrentSkipListSet;
import java.lang.ref.*;

import java.security.*;
import java.security.spec.*;
import javax.crypto.*;

import javax.crypto.spec.SecretKeySpec;
import javax.crypto.spec.IvParameterSpec;

import sun.security.jca.JCAUtil;

/**
 * Cipher wrapper class utilizing ucrypto APIs. This class currently supports
 * - AES/ECB/NOPADDING
 * - AES/CBC/NOPADDING
 * - AES/CTR/NOPADDING
 * - AES/CFB128/NOPADDING
 * (Support for GCM mode is inside the child class NativeGCMCipher)
 *
 * @since 1.9
 */
class NativeCipher extends CipherSpi {

    // public implementation classes
    public static final class AesEcbNoPadding extends NativeCipher {
        public AesEcbNoPadding() throws NoSuchAlgorithmException {
            super(UcryptoMech.CRYPTO_AES_ECB);
        }
        public AesEcbNoPadding(int keySize) throws NoSuchAlgorithmException {
            super(UcryptoMech.CRYPTO_AES_ECB, keySize);
        }
    }
    public static final class AesCbcNoPadding extends NativeCipher {
        public AesCbcNoPadding() throws NoSuchAlgorithmException {
            super(UcryptoMech.CRYPTO_AES_CBC);
        }
        public AesCbcNoPadding(int keySize) throws NoSuchAlgorithmException {
            super(UcryptoMech.CRYPTO_AES_CBC, keySize);
        }
    }
    public static final class AesCtrNoPadding extends NativeCipher {
        public AesCtrNoPadding() throws NoSuchAlgorithmException {
            super(UcryptoMech.CRYPTO_AES_CTR);
        }
    }
    public static final class AesCfb128NoPadding extends NativeCipher {
        public AesCfb128NoPadding() throws NoSuchAlgorithmException {
            super(UcryptoMech.CRYPTO_AES_CFB128);
        }
    }

    // ok as constants since AES is all we support
    public static final int AES_BLOCK_SIZE = 16;
    public static final String AES_KEY_ALGO = "AES";

    // fields set in constructor
    protected final UcryptoMech mech;
    protected String keyAlgo;
    protected int blockSize;
    protected int fixedKeySize;

    //
    // fields (re)set in every init()
    //
    protected CipherContextRef pCtxt = null;
    protected byte[] keyValue = null;
    protected byte[] iv = null;
    protected boolean initialized = false;
    protected boolean encrypt = true;
    protected int bytesBuffered = 0;

    // private utility methods for key re-construction
    private static final PublicKey constructPublicKey(byte[] encodedKey,
                                              String encodedKeyAlgorithm)
        throws InvalidKeyException, NoSuchAlgorithmException {

        PublicKey key = null;
        try {
            KeyFactory keyFactory =
                KeyFactory.getInstance(encodedKeyAlgorithm);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(encodedKey);
            key = keyFactory.generatePublic(keySpec);
        } catch (NoSuchAlgorithmException nsae) {
            throw new NoSuchAlgorithmException("No provider found for " +
                                               encodedKeyAlgorithm +
                                               " KeyFactory");
        } catch (InvalidKeySpecException ikse) {
            // Should never happen
            throw new InvalidKeyException("Cannot construct public key", ikse);
        }
        return key;
    }

    private static final PrivateKey constructPrivateKey(byte[] encodedKey,
                                                String encodedKeyAlgorithm)
        throws InvalidKeyException, NoSuchAlgorithmException {

        PrivateKey key = null;
        try {
            KeyFactory keyFactory =
                KeyFactory.getInstance(encodedKeyAlgorithm);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encodedKey);
            key = keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException nsae) {
            throw new NoSuchAlgorithmException("No provider found for " +
                                               encodedKeyAlgorithm +
                                               " KeyFactory");
        } catch (InvalidKeySpecException ikse) {
            // Should never happen
            throw new InvalidKeyException("Cannot construct private key", ikse);
        }
        return key;
    }

    private static final SecretKey constructSecretKey(byte[] encodedKey,
                                              String encodedKeyAlgorithm) {
        return new SecretKeySpec(encodedKey, encodedKeyAlgorithm);
    }

    // package-private utility method for general key re-construction
    static final Key constructKey(int keyType, byte[] encodedKey,
                                  String encodedKeyAlgorithm)
        throws InvalidKeyException, NoSuchAlgorithmException {
        Key result = null;
        switch (keyType) {
        case Cipher.SECRET_KEY:
            result = constructSecretKey(encodedKey,
                                        encodedKeyAlgorithm);
            break;
        case Cipher.PRIVATE_KEY:
            result = constructPrivateKey(encodedKey,
                                         encodedKeyAlgorithm);
            break;
        case Cipher.PUBLIC_KEY:
            result = constructPublicKey(encodedKey,
                                        encodedKeyAlgorithm);
            break;
        }
        return result;
    }

    NativeCipher(UcryptoMech mech, int fixedKeySize) throws NoSuchAlgorithmException {
        this.mech = mech;
        // defaults to AES - the only supported symmetric cipher algo
        this.blockSize = AES_BLOCK_SIZE;
        this.keyAlgo = AES_KEY_ALGO;
        this.fixedKeySize = fixedKeySize;
    }

    NativeCipher(UcryptoMech mech) throws NoSuchAlgorithmException {
        this(mech, -1);
    }

    @Override
    protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
        // Disallow change of mode for now since currently it's explicitly
        // defined in transformation strings
        throw new NoSuchAlgorithmException("Unsupported mode " + mode);
    }

    // see JCE spec
    @Override
    protected void engineSetPadding(String padding)
            throws NoSuchPaddingException {
        // Disallow change of padding for now since currently it's explicitly
        // defined in transformation strings
        throw new NoSuchPaddingException("Unsupported padding " + padding);
    }

    // see JCE spec
    @Override
    protected int engineGetBlockSize() {
        return blockSize;
    }

    // see JCE spec
    @Override
    protected synchronized int engineGetOutputSize(int inputLen) {
        return getOutputSizeByOperation(inputLen, true);
    }

    // see JCE spec
    @Override
    protected synchronized byte[] engineGetIV() {
        return (iv != null? iv.clone() : null);
    }

    // see JCE spec
    @Override
    protected synchronized AlgorithmParameters engineGetParameters() {
        AlgorithmParameters params = null;
        try {
            if (iv != null) {
                IvParameterSpec ivSpec = new IvParameterSpec(iv.clone());
                params = AlgorithmParameters.getInstance(keyAlgo);
                params.init(ivSpec);
            }
        } catch (GeneralSecurityException e) {
            // NoSuchAlgorithmException, NoSuchProviderException
            // InvalidParameterSpecException
            throw new UcryptoException("Could not encode parameters", e);
        }
        return params;
    }

    @Override
    protected int engineGetKeySize(Key key) throws InvalidKeyException {
        return checkKey(key) * 8;
    }

    // see JCE spec
    @Override
    protected synchronized void engineInit(int opmode, Key key,
            SecureRandom random) throws InvalidKeyException {
        try {
            engineInit(opmode, key, (AlgorithmParameterSpec)null, random);
        } catch (InvalidAlgorithmParameterException e) {
            throw new InvalidKeyException("init() failed", e);
        }
    }

    // see JCE spec
    @Override
    protected synchronized void engineInit(int opmode, Key key,
            AlgorithmParameterSpec params, SecureRandom random)
            throws InvalidKeyException, InvalidAlgorithmParameterException {
        checkKey(key);
        if (opmode != Cipher.ENCRYPT_MODE &&
            opmode != Cipher.DECRYPT_MODE &&
            opmode != Cipher.WRAP_MODE &&
            opmode != Cipher.UNWRAP_MODE) {
            throw new InvalidAlgorithmParameterException
                ("Unsupported mode: " + opmode);
        }
        boolean doEncrypt =
                (opmode == Cipher.ENCRYPT_MODE || opmode == Cipher.WRAP_MODE);

        byte[] ivBytes = null;
        if (mech == UcryptoMech.CRYPTO_AES_ECB) {
            if (params != null) {
                throw new InvalidAlgorithmParameterException
                        ("No Parameters for ECB mode");
            }
        } else {
            if (params != null) {
                if (!(params instanceof IvParameterSpec)) {
                    throw new InvalidAlgorithmParameterException
                            ("IvParameterSpec required. Received: " +
                            params.getClass().getName());
                } else {
                    ivBytes = ((IvParameterSpec) params).getIV();
                    if (ivBytes.length != blockSize) {
                        throw new InvalidAlgorithmParameterException
                             ("Wrong IV length: must be " + blockSize +
                              " bytes long. Received length:" + ivBytes.length);
                    }
                }
            } else {
                if (encrypt) {
                    // generate IV if none supplied for encryption
                    ivBytes = new byte[blockSize];
                    if (random == null) {
                        random = JCAUtil.getSecureRandom();
                    }
                    random.nextBytes(ivBytes);
                } else {
                    throw new InvalidAlgorithmParameterException
                            ("Parameters required for decryption");
                }
            }
        }
        init(doEncrypt, key.getEncoded().clone(), ivBytes);
    }

    // see JCE spec
    @Override
    protected synchronized void engineInit(int opmode, Key key,
            AlgorithmParameters params, SecureRandom random)
            throws InvalidKeyException, InvalidAlgorithmParameterException {
        AlgorithmParameterSpec spec = null;
        if (params != null) {
            try {
                spec = params.getParameterSpec(IvParameterSpec.class);
            } catch (InvalidParameterSpecException iaps) {
                throw new InvalidAlgorithmParameterException(iaps);
            }
        }
        engineInit(opmode, key, spec, random);
    }

    // see JCE spec
    @Override
    protected synchronized byte[] engineUpdate(byte[] in, int ofs, int len) {
        byte[] out = new byte[getOutputSizeByOperation(len, false)];
        int n = update(in, ofs, len, out, 0);
        if (n == 0) {
            return null;
        } else if (out.length != n) {
            out = Arrays.copyOf(out, n);
        }
        return out;
    }

    // see JCE spec
    @Override
    protected synchronized int engineUpdate(byte[] in, int inOfs, int inLen,
        byte[] out, int outOfs) throws ShortBufferException {
        int min = getOutputSizeByOperation(inLen, false);
        if (out.length - outOfs < min) {
            throw new ShortBufferException("min " + min + "-byte buffer needed");
        }
        return update(in, inOfs, inLen, out, outOfs);
    }

    // see JCE spec
    @Override
    protected synchronized void engineUpdateAAD(byte[] src, int ofs, int len)
            throws IllegalStateException {
        throw new IllegalStateException("No AAD can be supplied");
    }

    // see JCE spec
    @Override
    protected void engineUpdateAAD(ByteBuffer src)
            throws IllegalStateException {
        throw new IllegalStateException("No AAD can be supplied");
    }

    // see JCE spec
    @Override
    protected synchronized byte[] engineDoFinal(byte[] in, int ofs, int len)
            throws IllegalBlockSizeException, BadPaddingException {
        byte[] out = new byte[getOutputSizeByOperation(len, true)];
        try {
            // delegate to the other engineDoFinal(...) method
            int k = engineDoFinal(in, ofs, len, out, 0);
            if (out.length != k) {
                out = Arrays.copyOf(out, k);
            }
            return out;
        } catch (ShortBufferException e) {
            throw new UcryptoException("Internal Error", e);
        }
    }

    // see JCE spec
    @Override
    protected synchronized int engineDoFinal(byte[] in, int inOfs, int inLen,
                                             byte[] out, int outOfs)
            throws ShortBufferException, IllegalBlockSizeException,
            BadPaddingException {
        int k = 0;
        int min = getOutputSizeByOperation(inLen, true);
        if (out.length - outOfs < min) {
            throw new ShortBufferException("min " + min + "-byte buffer needed");
        }
        if (inLen > 0) {
            k = update(in, inOfs, inLen, out, outOfs);
            outOfs += k;
        }
        k += doFinal(out, outOfs);
        return k;
    }


    // see JCE spec
    @Override
    protected synchronized byte[] engineWrap(Key key)
            throws IllegalBlockSizeException, InvalidKeyException {
        byte[] result = null;
        try {
            byte[] encodedKey = key.getEncoded();
            if ((encodedKey == null) || (encodedKey.length == 0)) {
                throw new InvalidKeyException("Cannot get an encoding of " +
                                              "the key to be wrapped");
            }
            result = engineDoFinal(encodedKey, 0, encodedKey.length);
        } catch (BadPaddingException e) {
            // Should never happen for key wrapping
            throw new UcryptoException("Internal Error" , e);
        }
        return result;
    }

    // see JCE spec
    @Override
    protected synchronized Key engineUnwrap(byte[] wrappedKey,
            String wrappedKeyAlgorithm, int wrappedKeyType)
            throws InvalidKeyException, NoSuchAlgorithmException {

        byte[] encodedKey;
        Key result = null;
        try {
            encodedKey = engineDoFinal(wrappedKey, 0,
                                       wrappedKey.length);
        } catch (Exception e) {
            throw (InvalidKeyException)
                (new InvalidKeyException()).initCause(e);
        }

        return constructKey(wrappedKeyType, encodedKey, wrappedKeyAlgorithm);
    }

    final int checkKey(Key key) throws InvalidKeyException {
        if (key == null || key.getEncoded() == null) {
            throw new InvalidKeyException("Key cannot be null");
        } else {
            // check key algorithm and format
            if (!keyAlgo.equalsIgnoreCase(key.getAlgorithm())) {
                throw new InvalidKeyException("Key algorithm must be " +
                    keyAlgo);
            }
            if (!"RAW".equalsIgnoreCase(key.getFormat())) {
                throw new InvalidKeyException("Key format must be RAW");
            }
            int keyLen = key.getEncoded().length;
            if (fixedKeySize == -1) {
                // all 3 AES key lengths are allowed
                if (keyLen != 16 && keyLen != 24 && keyLen != 32) {
                    throw new InvalidKeyException("Key size is not valid." +
                        " Got key length of: " + keyLen);
                }
            } else {
                if (keyLen != fixedKeySize) {
                    throw new InvalidKeyException("Only " + fixedKeySize +
                        "-byte keys are accepted. Got: " + keyLen);
                }
            }
            // return the validated key length in bytes
            return keyLen;
        }
    }

    protected void reset(boolean doCancel) {
        initialized = false;
        bytesBuffered = 0;
        if (pCtxt != null) {
            pCtxt.dispose(doCancel);
            pCtxt = null;
        }
    }

    /**
     * calls ucrypto_encrypt_init(...) or ucrypto_decrypt_init(...)
     * @return pointer to the context
     */
    protected native static long nativeInit(int mech, boolean encrypt,
                                            byte[] key, byte[] iv,
                                            int tagLen, byte[] aad);

    /**
     * calls ucrypto_encrypt_update(...) or ucrypto_decrypt_update(...)
     * @return the length of output or if negative, an error status code
     */
    private native static int nativeUpdate(long pContext, boolean encrypt,
                                           byte[] in, int inOfs, int inLen,
                                           byte[] out, int outOfs);

    /**
     * calls ucrypto_encrypt_final(...) or ucrypto_decrypt_final(...)
     * @return the length of output or if negative, an error status code
     */
    native static int nativeFinal(long pContext, boolean encrypt,
                                          byte[] out, int outOfs);

    protected void ensureInitialized() {
        if (!initialized) {
            init(encrypt, keyValue, iv);
            if (!initialized) {
                throw new UcryptoException("Cannot initialize Cipher");
            }
        }
    }

    protected int getOutputSizeByOperation(int inLen, boolean isDoFinal) {
        if (inLen <= 0) {
            inLen = 0;
        }
        if (!isDoFinal && (inLen == 0)) {
            return 0;
        }
        return inLen + bytesBuffered;
    }

    // actual init() implementation - caller should clone key and iv if needed
    protected void init(boolean encrypt, byte[] keyVal, byte[] ivVal) {
        reset(true);
        this.encrypt = encrypt;
        this.keyValue = keyVal;
        this.iv = ivVal;
        long pCtxtVal = nativeInit(mech.value(), encrypt, keyValue, iv, 0, null);
        initialized = (pCtxtVal != 0L);
        if (initialized) {
            pCtxt = new CipherContextRef(this, pCtxtVal, encrypt);
        } else {
            throw new UcryptoException("Cannot initialize Cipher");
        }
    }

    // Caller MUST check and ensure output buffer has enough capacity
    private int update(byte[] in, int inOfs, int inLen, byte[] out, int outOfs) {
        ensureInitialized();
        if (inLen <= 0) { return 0; }

        int k = nativeUpdate(pCtxt.id, encrypt, in, inOfs, inLen, out, outOfs);
        if (k < 0) {
            reset(false);
            // cannot throw ShortBufferException here since it's too late
            // native context is invalid upon any failure
            throw new UcryptoException(-k);
        }
        bytesBuffered += (inLen - k);
        return k;
    }

    // Caller MUST check and ensure output buffer has enough capacity
    private int doFinal(byte[] out, int outOfs) throws IllegalBlockSizeException,
            BadPaddingException {
        try {
            ensureInitialized();

            int k = nativeFinal(pCtxt.id, encrypt, out, outOfs);
            if (k < 0) {
                String cause = UcryptoException.getErrorMessage(-k);
                if (cause.endsWith("_LEN_RANGE")) {
                    throw new IllegalBlockSizeException(cause);
                } else if (cause.endsWith("_DATA_INVALID")) {
                    throw new BadPaddingException(cause);
                } else {
                    throw new UcryptoException(-k);
                }
            }
            return k;
        } finally {
            reset(false);
        }
    }
}