org.bouncycastle.pqc.jcajce.provider.util

Class AsymmetricBlockCipher

java.lang.Object

javax.crypto.CipherSpi

org.bouncycastle.pqc.jcajce.provider.util.CipherSpiExt

org.bouncycastle.pqc.jcajce.provider.util.AsymmetricBlockCipher

Direct Known Subclasses:

McEliecePKCSCipherSpi

public abstract class AsymmetricBlockCipher
extends CipherSpiExt

The AsymmetricBlockCipher class extends CipherSpiExt. NOTE: Some Ciphers are using Padding. OneAndZeroesPadding is used as default padding. However padding can still be specified, but mode is not supported; if you try to instantiate the cipher with something else than "NONE" as mode NoSuchAlgorithmException is thrown.

Field Summary

Fields

Modifier and Type	Field and Description
protected java.io.ByteArrayOutputStream	buf Internal buffer
protected int	cipherTextSize The maximum number of bytes the cipher can encrypt.
protected int	maxPlainTextSize The maximum number of bytes the cipher can decrypt.
protected java.security.spec.AlgorithmParameterSpec	paramSpec ParameterSpec used with this cipher

Fields inherited from class org.bouncycastle.pqc.jcajce.provider.util.CipherSpiExt

DECRYPT_MODE, ENCRYPT_MODE, opMode

Constructor Summary

Constructors

Constructor and Description
AsymmetricBlockCipher() The AsymmetricBlockCipher() constructor

Method Summary

Modifier and Type	Method and Description
protected void	checkLength(int inLen) Check if the message length plus the length of the input length can be en/decrypted.
byte[]	doFinal(byte[] input, int inOff, int inLen) Finish a multiple-part encryption or decryption operation (depending on how this cipher was initialized).
int	doFinal(byte[] input, int inOff, int inLen, byte[] output, int outOff) Finish a multiple-part encryption or decryption operation (depending on how this cipher was initialized).
int	getBlockSize() Return the block size (in bytes).
byte[]	getIV() Return the initialization vector.
int	getOutputSize(int inLen) Return the length in bytes that an output buffer would need to be in order to hold the result of the next update or doFinal operation, given the input length inLen (in bytes).
java.security.spec.AlgorithmParameterSpec	getParameters() Returns the parameters used with this cipher.
protected abstract void	initCipherDecrypt(java.security.Key key, java.security.spec.AlgorithmParameterSpec params) Initialize the AsymmetricBlockCipher with a certain key for data encryption.
protected abstract void	initCipherEncrypt(java.security.Key key, java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom sr) Initialize the AsymmetricBlockCipher with a certain key for data encryption.
void	initDecrypt(java.security.Key key) Initialize the cipher for decryption by forwarding it to initDecrypt(Key, AlgorithmParameterSpec).
void	initDecrypt(java.security.Key key, java.security.spec.AlgorithmParameterSpec params) This method initializes the AsymmetricBlockCipher with a certain key for data decryption.
void	initEncrypt(java.security.Key key) Initializes the cipher for encryption by forwarding it to initEncrypt(Key, FlexiSecureRandom).
void	initEncrypt(java.security.Key key, java.security.spec.AlgorithmParameterSpec params) Initializes the cipher for encryption by forwarding it to initEncrypt(Key, FlexiSecureRandom, AlgorithmParameterSpec).
void	initEncrypt(java.security.Key key, java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom secureRandom) This method initializes the AsymmetricBlockCipher with a certain key for data encryption.
void	initEncrypt(java.security.Key key, java.security.SecureRandom random) Initialize this cipher for encryption by forwarding it to initEncrypt(Key, FlexiSecureRandom, AlgorithmParameterSpec).
protected abstract byte[]	messageDecrypt(byte[] input) Decrypt the ciphertext stored in input.
protected abstract byte[]	messageEncrypt(byte[] input) Encrypt the message stored in input.
protected void	setMode(java.lang.String modeName) Since asymmetric block ciphers do not support modes, this method does nothing.
protected void	setPadding(java.lang.String paddingName) Since asymmetric block ciphers do not support padding, this method does nothing.
byte[]	update(byte[] input, int inOff, int inLen) Continue a multiple-part encryption or decryption operation.
int	update(byte[] input, int inOff, int inLen, byte[] output, int outOff) Continue a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.

Methods inherited from class org.bouncycastle.pqc.jcajce.provider.util.CipherSpiExt

doFinal, doFinal, engineDoFinal, engineDoFinal, engineGetBlockSize, engineGetIV, engineGetKeySize, engineGetOutputSize, engineGetParameters, engineInit, engineInit, engineInit, engineSetMode, engineSetPadding, engineUpdate, engineUpdate, getKeySize, getName, update

Methods inherited from class javax.crypto.CipherSpi

engineDoFinal, engineUnwrap, engineUpdate, engineUpdateAAD, engineUpdateAAD, engineWrap

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

paramSpec

protected java.security.spec.AlgorithmParameterSpec paramSpec

ParameterSpec used with this cipher

buf

protected java.io.ByteArrayOutputStream buf

Internal buffer

maxPlainTextSize

protected int maxPlainTextSize

The maximum number of bytes the cipher can decrypt.

cipherTextSize

protected int cipherTextSize

The maximum number of bytes the cipher can encrypt.

Constructor Detail

AsymmetricBlockCipher

public AsymmetricBlockCipher()

The AsymmetricBlockCipher() constructor

Method Detail

getBlockSize

public final int getBlockSize()

Return the block size (in bytes). Note: although the ciphers extending this class are not block ciphers, the method was adopted to return the maximal plaintext and ciphertext sizes for non hybrid ciphers. If the cipher is hybrid, it returns 0.

Specified by:

getBlockSize in class CipherSpiExt

Returns:

if the cipher is not a hybrid one the max plain/cipher text size is returned, otherwise 0 is returned

getIV

public final byte[] getIV()

Description copied from class: CipherSpiExt

Return the initialization vector. This is useful in the context of password-based encryption or decryption, where the IV is derived from a user-provided passphrase.

Specified by:

getIV in class CipherSpiExt

Returns:

null since no initialization vector is used.

getOutputSize

public final int getOutputSize(int inLen)

Return the length in bytes that an output buffer would need to be in order to hold the result of the next update or doFinal operation, given the input length inLen (in bytes). This call takes into account any unprocessed (buffered) data from a previous update call, and padding. The actual output length of the next update() or doFinal() call may be smaller than the length returned by this method.

If the input length plus the length of the buffered data exceeds the maximum length, 0 is returned.

Specified by:

getOutputSize in class CipherSpiExt

Parameters:

inLen - the length of the input

Returns:

the length of the ciphertext or 0 if the input is too long.

getParameters

public final java.security.spec.AlgorithmParameterSpec getParameters()

Returns the parameters used with this cipher.

The returned parameters may be the same that were used to initialize this cipher, or may contain the default set of parameters or a set of randomly generated parameters used by the underlying cipher implementation (provided that the underlying cipher implementation uses a default set of parameters or creates new parameters if it needs parameters but was not initialized with any).

Specified by:

getParameters in class CipherSpiExt

Returns:

the parameters used with this cipher, or null if this cipher does not use any parameters.

initEncrypt

public final void initEncrypt(java.security.Key key)
                       throws java.security.InvalidKeyException

Initializes the cipher for encryption by forwarding it to initEncrypt(Key, FlexiSecureRandom).

If this cipher requires any algorithm parameters that cannot be derived from the given key, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption, and raise an InvalidKeyException if it is being initialized for decryption. The generated parameters can be retrieved using engineGetParameters or engineGetIV (if the parameter is an IV).

Parameters:

key - the encryption or decryption key.

Throws:

java.security.InvalidKeyException - if the given key is inappropriate for initializing this cipher.

initEncrypt

public final void initEncrypt(java.security.Key key,
                              java.security.SecureRandom random)
                       throws java.security.InvalidKeyException

Initialize this cipher for encryption by forwarding it to initEncrypt(Key, FlexiSecureRandom, AlgorithmParameterSpec).

If this cipher requires any algorithm parameters that cannot be derived from the given key, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption, and raise an InvalidKeyException if it is being initialized for decryption. The generated parameters can be retrieved using engineGetParameters or engineGetIV (if the parameter is an IV).

Parameters:

key - the encryption or decryption key.

random - the source of randomness.

Throws:

java.security.InvalidKeyException - if the given key is inappropriate for initializing this cipher.

initEncrypt

public final void initEncrypt(java.security.Key key,
                              java.security.spec.AlgorithmParameterSpec params)
                       throws java.security.InvalidKeyException,
                              java.security.InvalidAlgorithmParameterException

Initializes the cipher for encryption by forwarding it to initEncrypt(Key, FlexiSecureRandom, AlgorithmParameterSpec).

Parameters:

key - the encryption or decryption key.

params - the algorithm parameters.

Throws:

java.security.InvalidKeyException - if the given key is inappropriate for initializing this cipher.

java.security.InvalidAlgorithmParameterException - if the given algortihm parameters are inappropriate for this cipher, or if this cipher is being initialized for decryption and requires algorithm parameters and params is null.

initEncrypt

public final void initEncrypt(java.security.Key key,
                              java.security.spec.AlgorithmParameterSpec params,
                              java.security.SecureRandom secureRandom)
                       throws java.security.InvalidKeyException,
                              java.security.InvalidAlgorithmParameterException

This method initializes the AsymmetricBlockCipher with a certain key for data encryption.

If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them from random.

Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it

Specified by:

initEncrypt in class CipherSpiExt

Parameters:

key - the key which has to be used to encrypt data.

secureRandom - the source of randomness.

params - the algorithm parameters.

Throws:

java.security.InvalidKeyException - if the given key is inappropriate for initializing this cipher

java.security.InvalidAlgorithmParameterException - if the given algorithm parameters are inappropriate for this cipher, or if this cipher is being initialized for decryption and requires algorithm parameters and params is null.

initDecrypt

public final void initDecrypt(java.security.Key key)
                       throws java.security.InvalidKeyException

Initialize the cipher for decryption by forwarding it to initDecrypt(Key, AlgorithmParameterSpec).

If this cipher requires any algorithm parameters that cannot be derived from the given key, the underlying cipher implementation is supposed to generate the required parameters itself (using provider-specific default or random values) if it is being initialized for encryption, and raise an InvalidKeyException if it is being initialized for decryption. The generated parameters can be retrieved using engineGetParameters or engineGetIV (if the parameter is an IV).

Parameters:

key - the encryption or decryption key.

Throws:

java.security.InvalidKeyException - if the given key is inappropriate for initializing this cipher.

initDecrypt

public final void initDecrypt(java.security.Key key,
                              java.security.spec.AlgorithmParameterSpec params)
                       throws java.security.InvalidKeyException,
                              java.security.InvalidAlgorithmParameterException

This method initializes the AsymmetricBlockCipher with a certain key for data decryption.

If this cipher (including its underlying feedback or padding scheme) requires any random bytes (e.g., for parameter generation), it will get them from random.

Note that when a Cipher object is initialized, it loses all previously-acquired state. In other words, initializing a Cipher is equivalent to creating a new instance of that Cipher and initializing it

Specified by:

initDecrypt in class CipherSpiExt

Parameters:

key - the key which has to be used to decrypt data.

params - the algorithm parameters.

Throws:

java.security.InvalidKeyException - if the given key is inappropriate for initializing this cipher

java.security.InvalidAlgorithmParameterException - if the given algorithm parameters are inappropriate for this cipher, or if this cipher is being initialized for decryption and requires algorithm parameters and params is null.

update

public final byte[] update(byte[] input,
                           int inOff,
                           int inLen)

Continue a multiple-part encryption or decryption operation. This method just writes the input into an internal buffer.

Specified by:

update in class CipherSpiExt

Parameters:

input - byte array containing the next part of the input

inOff - index in the array where the input starts

inLen - length of the input

Returns:

a new buffer with the result (always empty)

update

public final int update(byte[] input,
                        int inOff,
                        int inLen,
                        byte[] output,
                        int outOff)

Continue a multiple-part encryption or decryption operation (depending on how this cipher was initialized), processing another data part.

Specified by:

update in class CipherSpiExt

Parameters:

input - the input buffer

inOff - the offset where the input starts

inLen - the input length

output - the output buffer

outOff - the offset where the result is stored

Returns:

the length of the output (always 0)

doFinal

public final byte[] doFinal(byte[] input,
                            int inOff,
                            int inLen)
                     throws javax.crypto.IllegalBlockSizeException,
                            javax.crypto.BadPaddingException

Finish a multiple-part encryption or decryption operation (depending on how this cipher was initialized).

Specified by:

doFinal in class CipherSpiExt

Parameters:

input - the input buffer

inOff - the offset where the input starts

inLen - the input length

Returns:

a new buffer with the result

Throws:

javax.crypto.IllegalBlockSizeException - if the plaintext or ciphertext size is too large.

javax.crypto.BadPaddingException - if the ciphertext is invalid.

doFinal

public final int doFinal(byte[] input,
                         int inOff,
                         int inLen,
                         byte[] output,
                         int outOff)
                  throws javax.crypto.ShortBufferException,
                         javax.crypto.IllegalBlockSizeException,
                         javax.crypto.BadPaddingException

Finish a multiple-part encryption or decryption operation (depending on how this cipher was initialized).

Specified by:

doFinal in class CipherSpiExt

Parameters:

input - the input buffer

inOff - the offset where the input starts

inLen - the input length

output - the buffer for the result

outOff - the offset where the result is stored

Returns:

the output length

Throws:

javax.crypto.ShortBufferException - if the output buffer is too small to hold the result.

javax.crypto.IllegalBlockSizeException - if the plaintext or ciphertext size is too large.

javax.crypto.BadPaddingException - if the ciphertext is invalid.

setMode

protected final void setMode(java.lang.String modeName)

Since asymmetric block ciphers do not support modes, this method does nothing.

Specified by:

setMode in class CipherSpiExt

Parameters:

modeName - the cipher mode (unused)

setPadding

protected final void setPadding(java.lang.String paddingName)

Since asymmetric block ciphers do not support padding, this method does nothing.

Specified by:

setPadding in class CipherSpiExt

Parameters:

paddingName - the name of the padding scheme (not used)

checkLength

protected void checkLength(int inLen)
                    throws javax.crypto.IllegalBlockSizeException

Check if the message length plus the length of the input length can be en/decrypted. This method uses the specific values maxPlainTextSize and cipherTextSize which are set by the implementations. If the input length plus the length of the internal buffer is greater than maxPlainTextSize for encryption or not equal to cipherTextSize for decryption, an IllegalBlockSizeException will be thrown.

Parameters:

inLen - length of the input to check

Throws:

javax.crypto.IllegalBlockSizeException - if the input length is invalid.

initCipherEncrypt

protected abstract void initCipherEncrypt(java.security.Key key,
                                          java.security.spec.AlgorithmParameterSpec params,
                                          java.security.SecureRandom sr)
                                   throws java.security.InvalidKeyException,
                                          java.security.InvalidAlgorithmParameterException

Initialize the AsymmetricBlockCipher with a certain key for data encryption.

Parameters:

key - the key which has to be used to encrypt data

params - the algorithm parameters

sr - the source of randomness

Throws:

java.security.InvalidKeyException - if the given key is inappropriate for initializing this cipher.

java.security.InvalidAlgorithmParameterException - if the given parameters are inappropriate for initializing this cipher.

initCipherDecrypt

protected abstract void initCipherDecrypt(java.security.Key key,
                                          java.security.spec.AlgorithmParameterSpec params)
                                   throws java.security.InvalidKeyException,
                                          java.security.InvalidAlgorithmParameterException

Initialize the AsymmetricBlockCipher with a certain key for data encryption.

Parameters:

key - the key which has to be used to decrypt data

params - the algorithm parameters

Throws:

java.security.InvalidKeyException - if the given key is inappropriate for initializing this cipher

java.security.InvalidAlgorithmParameterException - if the given parameters are inappropriate for initializing this cipher.

messageEncrypt

protected abstract byte[] messageEncrypt(byte[] input)
                                  throws javax.crypto.IllegalBlockSizeException,
                                         javax.crypto.BadPaddingException

Encrypt the message stored in input. The method should also perform an additional length check.

Parameters:

input - the message to be encrypted (usually the message length is less than or equal to maxPlainTextSize)

Returns:

the encrypted message (it has length equal to maxCipherTextSize_)

Throws:

javax.crypto.IllegalBlockSizeException - if the input is inappropriate for this cipher.

javax.crypto.BadPaddingException - if the input format is invalid.

messageDecrypt

protected abstract byte[] messageDecrypt(byte[] input)
                                  throws javax.crypto.IllegalBlockSizeException,
                                         javax.crypto.BadPaddingException

Decrypt the ciphertext stored in input. The method should also perform an additional length check.

Parameters:

input - the ciphertext to be decrypted (the ciphertext length is less than or equal to maxCipherTextSize)

Returns:

the decrypted message

Throws:

javax.crypto.IllegalBlockSizeException - if the input is inappropriate for this cipher.

javax.crypto.BadPaddingException - if the input format is invalid.