https://commons.apache.org/proper/commons-crypto/: Apache Commons Crypto is a cryptographic library optimized with AES-NI (Advanced Encryption Standard New Instructions). It provides Java API for both cipher level and Java stream level. Developers can use it to implement high performance AES encryption/decryption with the minimum code and effort. Please note that Crypto doesn't implement the cryptographic algorithm such as AES directly. It wraps to Openssl or JCE which implement the algorithms. Features -------- 1. Cipher API for low level cryptographic operations. 2. Java stream API (CryptoInputStream/CryptoOutputStream) for high level stream encryption/decryption. 3. Both optimized with high performance AES encryption/decryption. (1400 MB/s - 1700 MB/s throughput in modern Xeon processors). 4. JNI-based implementation to achieve comparable performance to the native C/C++ version based on OpenSsl. 5. Portable across various operating systems (currently only Linux/MacOSX/Windows); Apache Commons Crypto loads the library according to your machine environment (it checks system properties, `os.name` and `os.arch`). 6. Simple usage. Add the commons-crypto-(version).jar file to your classpath. Export restrictions ------------------- This distribution includes cryptographic software. The country in which you currently reside may have restrictions on the import, possession, use, and/or re-export to another country, of encryption software. BEFORE using any encryption software, please check your country's laws, regulations and policies concerning the import, possession, or use, and re-export of encryption software, to see if this is permitted. See <http://www.wassenaar.org/> for more information. The U.S. Government Department of Commerce, Bureau of Industry and Security (BIS), has classified this software as Export Commodity Control Number (ECCN) 5D002.C.1, which includes information security software using or performing cryptographic functions with asymmetric algorithms. The form and manner of this Apache Software Foundation distribution makes it eligible for export under the License Exception ENC Technology Software Unrestricted (TSU) exception (see the BIS Export Administration Regulations, Section 740.13) for both object code and source code. The following provides more details on the included cryptographic software: * Commons Crypto use [Java Cryptography Extension](http://docs.oracle.com/javase/8/docs/technotes/guides/security/crypto/CryptoSpec.html) provided by Java * Commons Crypto link to and use [OpenSSL](https://www.openssl.org/) ciphers (The Apache Software Foundation)
  • Colin Ma
  • Xianda Ke
  • Ke Jia
  • George Kankava
  • Tian Jianguo
  • Adam Retter (Evolved Binary)
  • Aaron T Myers
  • Andrew Wang
  • Chris Nauroth
  • Colin P. McCabe
  • Dapeng Sun
  • Dian Fu
  • Dong Chen
  • Ferdinand Xu
  • Haifeng Chen
  • Marcelo Vanzin
  • Uma Maheswara Rao G
  • Yi Liu
  • Gary Gregory 
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.

/**
 * 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.commons.crypto.cipher;

import java.io.Closeable;
import java.nio.ByteBuffer;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.spec.AlgorithmParameterSpec;

import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.ShortBufferException;


The interface of cryptographic cipher for encryption and decryption.


Note that implementations must provide a constructor that has 2 parameters:


a Properties instance and a String (transformation)

/**
 * The interface of cryptographic cipher for encryption and decryption.
 *
 * <p>
 * Note that implementations must provide a constructor that has 2 parameters:
 * <br>
 * a Properties instance and a String (transformation)
 *
 */
public interface CryptoCipher extends Closeable {

    
Returns the block size (in bytes).

Returns:the block size (in bytes), or 0 if the underlying algorithm is
not a block cipher
/**
     * Returns the block size (in bytes).
     *
     * @return the block size (in bytes), or 0 if the underlying algorithm is
     * not a block cipher
     */
    int getBlockSize();

    
Returns the algorithm name of this CryptoCipher object. 
This is the same name that was specified in one of the CryptoCipherFactory#getInstance calls that created this CryptoCipher object.. 
Returns:the algorithm name of this CryptoCipher object.
/**
     * Returns the algorithm name of this {@code CryptoCipher} object.
     *
     * <p>This is the same name that was specified in one of the
     * {@code CryptoCipherFactory#getInstance} calls that created this
     * {@code CryptoCipher} object..
     *
     * @return the algorithm name of this {@code CryptoCipher} object.
     */
    String getAlgorithm();

    
Initializes the cipher with mode, key and iv.

Params:
Throws:
  • InvalidKeyException – if the given key is inappropriate for
        initializing this cipher, or its keysize exceeds the maximum
        allowable keysize (as determined from the configured jurisdiction
        policy files).
  • InvalidAlgorithmParameterException – if the given algorithm parameters are inappropriate for this cipher, or this cipher requires algorithm parameters and params is null, or the given algorithm parameters imply a cryptographic strength that would exceed the legal limits (as determined from the configured jurisdiction policy files).
/**
     * Initializes the cipher with mode, key and iv.
     *
     * @param mode {@link javax.crypto.Cipher#ENCRYPT_MODE} or
     *             {@link javax.crypto.Cipher#DECRYPT_MODE}
     * @param key crypto key for the cipher
     * @param params the algorithm parameters
     * @throws InvalidKeyException if the given key is inappropriate for
     *         initializing this cipher, or its keysize exceeds the maximum
     *         allowable keysize (as determined from the configured jurisdiction
     *         policy files).
     * @throws InvalidAlgorithmParameterException if the given algorithm
     *         parameters are inappropriate for this cipher, or this cipher
     *         requires algorithm parameters and {@code params} is null, or
     *         the given algorithm parameters imply a cryptographic strength
     *         that would exceed the legal limits (as determined from the
     *         configured jurisdiction policy files).
     */
    void init(int mode, Key key, AlgorithmParameterSpec params)
            throws InvalidKeyException, InvalidAlgorithmParameterException;

    
Continues a multiple-part encryption/decryption operation. The data is
encrypted or decrypted, depending on how this cipher was initialized.

Params:
  • inBuffer – the input ByteBuffer
  • outBuffer – the output ByteBuffer
Throws:
Returns:int number of bytes stored in output
/**
     * Continues a multiple-part encryption/decryption operation. The data is
     * encrypted or decrypted, depending on how this cipher was initialized.
     *
     * @param inBuffer the input ByteBuffer
     * @param outBuffer the output ByteBuffer
     * @return int number of bytes stored in {@code output}
     * @throws ShortBufferException if there is insufficient space in the output
     *         buffer
     */
    int update(ByteBuffer inBuffer, ByteBuffer outBuffer)
            throws ShortBufferException;

    
Continues a multiple-part encryption/decryption operation. The data is
encrypted or decrypted, depending on how this cipher was initialized.

Params:
  • input – the input byte array
  • inputOffset – the offset in input where the input starts
  • inputLen – the input length
  • output – the byte array for the result
  • outputOffset – the offset in output where the result is stored
Throws:
Returns:the number of bytes stored in output
/**
     * Continues a multiple-part encryption/decryption operation. The data is
     * encrypted or decrypted, depending on how this cipher was initialized.
     *
     * @param input the input byte array
     * @param inputOffset the offset in input where the input starts
     * @param inputLen the input length
     * @param output the byte array for the result
     * @param outputOffset the offset in output where the result is stored
     * @return the number of bytes stored in output
     * @throws ShortBufferException if there is insufficient space in the output
     *         byte array
     */
    int update(byte[] input, int inputOffset, int inputLen, byte[] output,
            int outputOffset) throws ShortBufferException;

    
Encrypts or decrypts data in a single-part operation, or finishes a
multiple-part operation.

Params:
  • inBuffer – the input ByteBuffer
  • outBuffer – the output ByteBuffer
Throws:
  • BadPaddingException – if this cipher is in decryption mode, and
        (un)padding has been requested, but the decrypted data is not
        bounded by the appropriate padding bytes
  • IllegalBlockSizeException – if this cipher is a block cipher, no
        padding has been requested (only in encryption mode), and the
        total input length of the data processed by this cipher is not a
        multiple of block size; or if this encryption algorithm is unable
        to process the input data provided.
  • ShortBufferException – if the given output buffer is too small to
        hold the result
Returns:int number of bytes stored in output
/**
     * Encrypts or decrypts data in a single-part operation, or finishes a
     * multiple-part operation.
     *
     * @param inBuffer the input ByteBuffer
     * @param outBuffer the output ByteBuffer
     * @return int number of bytes stored in {@code output}
     * @throws BadPaddingException if this cipher is in decryption mode, and
     *         (un)padding has been requested, but the decrypted data is not
     *         bounded by the appropriate padding bytes
     * @throws IllegalBlockSizeException if this cipher is a block cipher, no
     *         padding has been requested (only in encryption mode), and the
     *         total input length of the data processed by this cipher is not a
     *         multiple of block size; or if this encryption algorithm is unable
     *         to process the input data provided.
     * @throws ShortBufferException if the given output buffer is too small to
     *         hold the result
     */
    int doFinal(ByteBuffer inBuffer, ByteBuffer outBuffer)
            throws ShortBufferException, IllegalBlockSizeException,
            BadPaddingException;

    
Encrypts or decrypts data in a single-part operation, or finishes a
multiple-part operation.

Params:
  • input – the input byte array
  • inputOffset – the offset in input where the input starts
  • inputLen – the input length
  • output – the byte array for the result
  • outputOffset – the offset in output where the result is stored
Throws:
  • ShortBufferException – if the given output byte array is too small
        to hold the result
  • BadPaddingException – if this cipher is in decryption mode, and
        (un)padding has been requested, but the decrypted data is not
        bounded by the appropriate padding bytes
  • IllegalBlockSizeException – if this cipher is a block cipher, no
        padding has been requested (only in encryption mode), and the
        total input length of the data processed by this cipher is not a
        multiple of block size; or if this encryption algorithm is unable
        to process the input data provided.
Returns:the number of bytes stored in output
/**
     * Encrypts or decrypts data in a single-part operation, or finishes a
     * multiple-part operation.
     *
     * @param input the input byte array
     * @param inputOffset the offset in input where the input starts
     * @param inputLen the input length
     * @param output the byte array for the result
     * @param outputOffset the offset in output where the result is stored
     * @return the number of bytes stored in output
     * @throws ShortBufferException if the given output byte array is too small
     *         to hold the result
     * @throws BadPaddingException if this cipher is in decryption mode, and
     *         (un)padding has been requested, but the decrypted data is not
     *         bounded by the appropriate padding bytes
     * @throws IllegalBlockSizeException if this cipher is a block cipher, no
     *         padding has been requested (only in encryption mode), and the
     *         total input length of the data processed by this cipher is not a
     *         multiple of block size; or if this encryption algorithm is unable
     *         to process the input data provided.
     */
    int doFinal(byte[] input, int inputOffset, int inputLen, byte[] output,
            int outputOffset) throws ShortBufferException,
            IllegalBlockSizeException, BadPaddingException;

    
Continues a multi-part update of the Additional Authentication
Data (AAD).

 Calls to this method provide AAD to the cipher when operating in modes such as AEAD (GCM). If this cipher is operating in GCM mode, all AAD must be supplied before beginning operations on the ciphertext (via the update and doFinal methods). 
Params:
  • aad – the buffer containing the Additional Authentication Data
Throws:
  • IllegalArgumentException – if the aad byte array is null
  • IllegalStateException – if this cipher is in a wrong state (e.g., has not been initialized), does not accept AAD, or if operating in either GCM or CCM mode and one of the update methods has already been called for the active encryption/decryption operation
  • UnsupportedOperationException – if the corresponding method
has not been overridden by an implementation
/**
     * Continues a multi-part update of the Additional Authentication
     * Data (AAD).
     * <p>
     * Calls to this method provide AAD to the cipher when operating in
     * modes such as AEAD (GCM).  If this cipher is operating in
     * GCM mode, all AAD must be supplied before beginning
     * operations on the ciphertext (via the {@code update} and
     * {@code doFinal} methods).
     *
     * @param aad the buffer containing the Additional Authentication Data
     *
     * @throws IllegalArgumentException if the {@code aad}
     * byte array is null
     * @throws IllegalStateException if this cipher is in a wrong state
     * (e.g., has not been initialized), does not accept AAD, or if
     * operating in either GCM or CCM mode and one of the {@code update}
     * methods has already been called for the active
     * encryption/decryption operation
     * @throws UnsupportedOperationException if the corresponding method
     * has not been overridden by an implementation
     *
     */
    default void updateAAD(final byte[] aad)
            throws IllegalArgumentException, IllegalStateException, UnsupportedOperationException {
      throw new UnsupportedOperationException();
    }

    
Continues a multi-part update of the Additional Authentication
Data (AAD).

 Calls to this method provide AAD to the cipher when operating in modes such as AEAD (GCM). If this cipher is operating in GCM mode, all AAD must be supplied before beginning operations on the ciphertext (via the update and doFinal methods). 
Params:
  • aad – the buffer containing the Additional Authentication Data
Throws:
  • IllegalArgumentException – if the aad byte array is null
  • IllegalStateException – if this cipher is in a wrong state (e.g., has not been initialized), does not accept AAD, or if operating in either GCM or CCM mode and one of the update methods has already been called for the active encryption/decryption operation
  • UnsupportedOperationException – if the corresponding method
has not been overridden by an implementation
/**
     * Continues a multi-part update of the Additional Authentication
     * Data (AAD).
     * <p>
     * Calls to this method provide AAD to the cipher when operating in
     * modes such as AEAD (GCM).  If this cipher is operating in
     * GCM mode, all AAD must be supplied before beginning
     * operations on the ciphertext (via the {@code update} and
     * {@code doFinal} methods).
     *
     * @param aad the buffer containing the Additional Authentication Data
     *
     * @throws IllegalArgumentException if the {@code aad}
     * byte array is null
     * @throws IllegalStateException if this cipher is in a wrong state
     * (e.g., has not been initialized), does not accept AAD, or if
     * operating in either GCM or CCM mode and one of the {@code update}
     * methods has already been called for the active
     * encryption/decryption operation
     * @throws UnsupportedOperationException if the corresponding method
     * has not been overridden by an implementation
     *
     */
    default void updateAAD(final ByteBuffer aad)
            throws IllegalArgumentException, IllegalStateException, UnsupportedOperationException {
      throw new UnsupportedOperationException();
    }
}