com.sun.crypto.provider.KeyWrapCipher Maven / Gradle / Ivy

The actual output length of the next update or * doFinal call may be smaller than the length returned * by this method. * * @param inLen the input length (in bytes) * * @return the required output buffer size (in bytes) */ protected int engineGetOutputSize(int inLen) { int result; if (opmode == Cipher.ENCRYPT_MODE || opmode == Cipher.WRAP_MODE) { result = (dataIdx > 0? Math.addExact(inLen, dataIdx - SEMI_BLKSIZE) : inLen); // calculate padding length based on plaintext length int padLen = 0; if (padding != null) { padLen = padding.padLength(result); } else if (cipher instanceof AESKeyWrapPadded) { int n = result % SEMI_BLKSIZE; if (n != 0) { padLen = SEMI_BLKSIZE - n; } } // then add the first semiblock and padLen to result result = Math.addExact(result, SEMI_BLKSIZE + padLen); } else { result = inLen - SEMI_BLKSIZE; if (dataIdx > 0) { result = Math.addExact(result, dataIdx); } } return result; } /** * Returns the initialization vector (IV) in a new buffer. * * @return the user-specified iv, or null if the underlying algorithm does * not use an IV, or if the IV has not yet been set. */ @Override protected byte[] engineGetIV() { byte[] iv = cipher.getIV(); return (iv == null? null : iv.clone()); } // actual impl for various engineInit(...) methods private void implInit(int opmode, Key key, byte[] iv, SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException { byte[] keyBytes = key.getEncoded(); if (keyBytes == null) { throw new InvalidKeyException("Null key"); } this.opmode = opmode; boolean decrypting = (opmode == Cipher.DECRYPT_MODE || opmode == Cipher.UNWRAP_MODE); try { cipher.init(decrypting, key.getAlgorithm(), keyBytes, iv); dataBuf = null; dataIdx = 0; } finally { Arrays.fill(keyBytes, (byte) 0); } } /** * Initializes this cipher with a key and a source of randomness. * * @param opmode the operation mode of this cipher. * @param key the secret key. * @param random the source of randomness. * * @exception InvalidKeyException if the given key is inappropriate for * initializing this cipher. */ @Override protected void engineInit(int opmode, Key key, SecureRandom random) throws InvalidKeyException { try { implInit(opmode, key, (byte[])null, random); } catch (InvalidAlgorithmParameterException iae) { // should never happen throw new AssertionError(iae); } } /** * Initializes this cipher with a key, a set of algorithm parameters, * and a source of randomness. * * @param opmode the operation mode of this cipher. * @param key the secret key. * @param params the algorithm parameters; if not null, must be of type * IvParameterSpec * @param random the source of randomness. * * @exception InvalidKeyException if the given key is inappropriate for * initializing this cipher * @exception InvalidAlgorithmParameterException if the given algorithm * parameters is invalid. */ @Override protected void engineInit(int opmode, Key key, AlgorithmParameterSpec params, SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException { if (params != null && !(params instanceof IvParameterSpec)) { throw new InvalidAlgorithmParameterException( "Only IvParameterSpec is accepted"); } byte[] iv = (params == null? null : ((IvParameterSpec)params).getIV()); implInit(opmode, key, iv, random); } /** * Initializes this cipher with a key, a set of algorithm parameters, * and a source of randomness. * * @param opmode the operation mode of this cipher. * @param key the secret key. * @param params the algorithm parameters; if not null, must be able to * be converted to IvParameterSpec. * @param random the source of randomness. * * @exception InvalidKeyException if the given key is inappropriate. * @exception InvalidAlgorithmParameterException if the given algorithm * parameters is invalid. */ @Override protected void engineInit(int opmode, Key key, AlgorithmParameters params, SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException { byte[] iv = null; if (params != null) { try { AlgorithmParameterSpec spec = params.getParameterSpec(IvParameterSpec.class); iv = ((IvParameterSpec)spec).getIV(); } catch (InvalidParameterSpecException ispe) { throw new InvalidAlgorithmParameterException( "Only IvParameterSpec is accepted"); } } try { implInit(opmode, key, iv, random); } catch (IllegalArgumentException iae) { throw new InvalidAlgorithmParameterException(iae.getMessage()); } } /** * See CipherSpi.engineUpdate(...) - buffers data internally as * only single part operation is supported. * * @param in the input buffer. * @param inOffset the offset in in where the input * starts. * @param inLen the input length. * * @return null. */ @Override protected byte[] engineUpdate(byte[] in, int inOffset, int inLen) { if (opmode != Cipher.ENCRYPT_MODE && opmode != Cipher.DECRYPT_MODE) { throw new IllegalStateException ("Cipher not initialized for update"); } implUpdate(in, inOffset, inLen); return null; } /** * See CipherSpi.engineUpdate(...) - buffers data internally as * only single part operation is supported. * * @param in the input buffer. * @param inOffset the offset in in where the input * starts. * @param inLen the input length. * @param out the buffer for the result. * @param outOffset the offset in out where the result * is stored. * * @return n/a. * * @exception IllegalStateException upon invocation of this method. */ @Override protected int engineUpdate(byte[] in, int inOffset, int inLen, byte[] out, int outOffset) throws ShortBufferException { if (opmode != Cipher.ENCRYPT_MODE && opmode != Cipher.DECRYPT_MODE) { throw new IllegalStateException ("Cipher not initialized for update"); } implUpdate(in, inOffset, inLen); return 0; } // actual impl for various engineUpdate(...) methods private void implUpdate(byte[] in, int inOfs, int inLen) { if (inLen <= 0) return; if (opmode == Cipher.ENCRYPT_MODE && dataIdx == 0) { // the first semiblock is for iv, store data after it dataIdx = SEMI_BLKSIZE; } store(in, inOfs, inLen); } /** * See CipherSpi.engineDoFinal(...) * * @param input the input buffer * @param inputOffset the offset in in where the input * starts * @param inputLen the input length. * * @return n/a. * * @exception IllegalStateException upon invocation of this method. */ @Override protected byte[] engineDoFinal(byte[] in, int inOfs, int inLen) throws IllegalBlockSizeException, BadPaddingException { int estOutLen = engineGetOutputSize(inLen); byte[] out = new byte[estOutLen]; try { int outLen = engineDoFinal(in, inOfs, inLen, out, 0); if (outLen < estOutLen) { try { return Arrays.copyOf(out, outLen); } finally { Arrays.fill(out, (byte)0); } } else { return out; } } catch (ShortBufferException sbe) { // should never happen throw new AssertionError(sbe); } } /** * See CipherSpi.doFinal(...) * * @param in the input buffer. * @param inOffset the offset in in where the input * starts. * @param inLen the input length. * @param out the buffer for the result. * @param outOffset the ofset in out where the result * is stored. * * @return n/a. * * @exception IllegalStateException upon invocation of this method. */ protected int engineDoFinal(byte[] in, int inOfs, int inLen, byte[] out, int outOfs) throws IllegalBlockSizeException, ShortBufferException, BadPaddingException { if (opmode != Cipher.ENCRYPT_MODE && opmode != Cipher.DECRYPT_MODE) { throw new IllegalStateException ("Cipher not initialized for doFinal"); } int estOutLen = engineGetOutputSize(inLen); if (out.length - outOfs < estOutLen) { throw new ShortBufferException("Need at least " + estOutLen); } try { // cannot write out the result for decryption due to verification // requirement if (outOfs == 0 && opmode == Cipher.ENCRYPT_MODE) { return implDoFinal(in, inOfs, inLen, out); } else { // use 'dataBuf' as output buffer and then copy into 'out' // make sure 'dataBuf' is large enough store(null, 0, inLen); int outLen = implDoFinal(in, inOfs, inLen, dataBuf); if (outLen > estOutLen) { throw new AssertionError ("Actual output length exceeds estimated length"); } System.arraycopy(dataBuf, 0, out, outOfs, outLen); return outLen; } } finally { if (dataBuf != null) { Arrays.fill(dataBuf, (byte)0); } dataBuf = null; dataIdx = 0; } } // actual impl for various engineDoFinal(...) methods. // prepare 'out' buffer with the buffered bytes in 'dataBuf', // and the to-be-processed bytes in 'in', then perform single-part // encryption/decrytion over 'out' buffer private int implDoFinal(byte[] in, int inOfs, int inLen, byte[] out) throws IllegalBlockSizeException, BadPaddingException, ShortBufferException { int len = (out == dataBuf? dataIdx : 0); // copy over the buffered bytes if out != dataBuf if (out != dataBuf && dataIdx > 0) { System.arraycopy(dataBuf, 0, out, 0, dataIdx); len = dataIdx; } if (opmode == Cipher.ENCRYPT_MODE && len == 0) { len = SEMI_BLKSIZE; // reserve space for the ICV if encryption } if (inLen > 0) { System.arraycopy(in, inOfs, out, len, inLen); len += inLen; } try { return (opmode == Cipher.ENCRYPT_MODE ? helperEncrypt(out, len) : helperDecrypt(out, len)); } finally { if (dataBuf != null && dataBuf != out) { Arrays.fill(dataBuf, (byte)0); } } } // helper routine for in-place encryption. // 'inBuf' = semiblock | plain text | extra bytes if padding is used // 'inLen' = semiblock length + plain text length private int helperEncrypt(byte[] inBuf, int inLen) throws IllegalBlockSizeException, ShortBufferException { // pad data if padding is used if (padding != null) { int paddingLen = padding.padLength(inLen - SEMI_BLKSIZE); if (inLen + paddingLen > inBuf.length) { throw new AssertionError("encrypt buffer too small"); } try { padding.padWithLen(inBuf, inLen, paddingLen); inLen += paddingLen; } catch (ShortBufferException sbe) { // should never happen throw new AssertionError(sbe); } } return cipher.encryptFinal(inBuf, 0, inLen, null, 0); } // helper routine for in-place decryption. // 'inBuf' = cipher text // 'inLen' = cipher text length private int helperDecrypt(byte[] inBuf, int inLen) throws IllegalBlockSizeException, BadPaddingException, ShortBufferException { int outLen = cipher.decryptFinal(inBuf, 0, inLen, null, 0); // unpad data if padding is used if (padding != null) { int padIdx = padding.unpad(inBuf, 0, outLen); if (padIdx <= 0) { throw new BadPaddingException("Bad Padding: " + padIdx); } outLen = padIdx; } return outLen; } /** * Returns the parameters used with this cipher. * * @return AlgorithmParameters object containing IV, or null if this cipher * does not use any parameters. */ @Override protected AlgorithmParameters engineGetParameters() { AlgorithmParameters params = null; byte[] iv = cipher.getIV(); if (iv == null) { iv = (cipher instanceof AESKeyWrap? AESKeyWrap.ICV1 : AESKeyWrapPadded.ICV2); } try { params = AlgorithmParameters.getInstance("AES"); params.init(new IvParameterSpec(iv)); } catch (NoSuchAlgorithmException | InvalidParameterSpecException e) { // should never happen throw new AssertionError(); } return params; } /** * Returns the key size of the given key object in number of bits. * * @param key the key object. * * @return the "effective" key size of the given key object. * * @exception InvalidKeyException if key is invalid. */ protected int engineGetKeySize(Key key) throws InvalidKeyException { byte[] encoded = key.getEncoded(); if (encoded == null) { throw new InvalidKeyException("Cannot decide key length"); } // only need length Arrays.fill(encoded, (byte) 0); int keyLen = encoded.length; if (!key.getAlgorithm().equalsIgnoreCase("AES") || !AESCrypt.isKeySizeValid(keyLen) || (fixedKeySize != -1 && fixedKeySize != keyLen)) { throw new InvalidKeyException("Invalid key length: " + keyLen + " bytes"); } return Math.multiplyExact(keyLen, 8); } /** * Wrap a key. * * @param key the key to be wrapped. * * @return the wrapped key. * * @exception IllegalBlockSizeException if this cipher is a block * cipher, no padding has been requested, and the length of the * encoding of the key to be wrapped is not a * multiple of the block size. * * @exception InvalidKeyException if it is impossible or unsafe to * wrap the key with this cipher (e.g., a hardware protected key is * being passed to a software only cipher). */ @Override protected byte[] engineWrap(Key key) throws IllegalBlockSizeException, InvalidKeyException { if (opmode != Cipher.WRAP_MODE) { throw new IllegalStateException("Cipher not initialized for wrap"); } byte[] encoded = key.getEncoded(); if ((encoded == null) || (encoded.length == 0)) { throw new InvalidKeyException("Cannot get an encoding of " + "the key to be wrapped"); } // output size is known, allocate output buffer byte[] out = new byte[engineGetOutputSize(encoded.length)]; // reserve the first semiblock and do not write data int len = SEMI_BLKSIZE; System.arraycopy(encoded, 0, out, len, encoded.length); len += encoded.length; // discard key data Arrays.fill(encoded, (byte) 0); try { int outLen = helperEncrypt(out, len); if (outLen != out.length) { throw new AssertionError("Wrong output buffer size"); } return out; } catch (ShortBufferException sbe) { // should never happen throw new AssertionError(); } } /** * Unwrap a previously wrapped key. * * @param wrappedKey the key to be unwrapped. * * @param wrappedKeyAlgorithm the algorithm the wrapped key is for. * * @param wrappedKeyType the type of the wrapped key. * This is one of Cipher.SECRET_KEY, * Cipher.PRIVATE_KEY, or Cipher.PUBLIC_KEY. * * @return the unwrapped key. * * @exception NoSuchAlgorithmException if no installed providers * can create keys of type wrappedKeyType for the * wrappedKeyAlgorithm. * * @exception InvalidKeyException if wrappedKey does not * represent a wrapped key of type wrappedKeyType for * the wrappedKeyAlgorithm. */ @Override protected Key engineUnwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, int wrappedKeyType) throws InvalidKeyException, NoSuchAlgorithmException { if (opmode != Cipher.UNWRAP_MODE) { throw new IllegalStateException ("Cipher not initialized for unwrap"); } byte[] buf = wrappedKey.clone(); try { int outLen = helperDecrypt(buf, buf.length); return ConstructKeys.constructKey(buf, 0, outLen, wrappedKeyAlgorithm, wrappedKeyType); } catch (ShortBufferException sbe) { // should never happen throw new AssertionError(); } catch (IllegalBlockSizeException | BadPaddingException e) { throw new InvalidKeyException(e); } finally { Arrays.fill(buf, (byte) 0); } } }