Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.pqc.jcajce.provider.util;
  
  import java.security.Key;
  
The AsymmetricHybridCipher 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.
 
 public abstract class AsymmetricHybridCipher
     extends CipherSpiExt
 {

    
ParameterSpec used with this cipher
 
     protected AlgorithmParameterSpec paramSpec;

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

Parameters:
modeName the cipher mode (unused)
 
     protected final void setMode(String modeName)
     {
         // empty
     }

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

Parameters:
paddingName the name of the padding scheme (not used)
 
     protected final void setPadding(String paddingName)
     {
         // empty
     }

    

Returns:
null since no initialization vector is used.
 
     public final byte[] getIV()
     {
         return null;
     }

    

Returns:
0 since the implementing algorithms are not block ciphers
 
     public final int getBlockSize()
     {
         return 0;
     }

    
Return 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).

Returns:
the parameters used with this cipher, or null if this cipher does not use any parameters.
 
     public final AlgorithmParameterSpec getParameters()
     {
         return ;
     }

    
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.

Parameters:
inLen the length of the input
Returns:
the length of the output of the next update() or doFinal() call
 
     public final int getOutputSize(int inLen)
     {
         return  ==  ? encryptOutputSize(inLen)
            : decryptOutputSize(inLen);
    }

    
Initialize the cipher for encryption by forwarding it to initEncrypt(java.security.Key,java.security.spec.AlgorithmParameterSpec,java.security.SecureRandom).

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 getParameters().

Parameters:
key the encryption key
Throws:
java.security.InvalidKeyException if the given key is inappropriate for initializing this cipher.
java.security.InvalidParameterException if this cipher needs algorithm parameters for initialization and cannot generate parameters itself.
    public final void initEncrypt(Key key)
        throws InvalidKeyException
    {
        try
        {
            initEncrypt(keynullnew SecureRandom());
        }
        catch (InvalidAlgorithmParameterException e)
        {
            throw new InvalidParameterException(
                "This cipher needs algorithm parameters for initialization (cannot be null).");
        }
    }

    
Initialize this cipher for encryption by forwarding it to initEncrypt(java.security.Key,java.security.spec.AlgorithmParameterSpec,java.security.SecureRandom).

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 getParameters().

Parameters:
key the encryption key
random the source of randomness
Throws:
java.security.InvalidKeyException if the given key is inappropriate for initializing this cipher.
java.security.InvalidParameterException if this cipher needs algorithm parameters for initialization and cannot generate parameters itself.
    public final void initEncrypt(Key keySecureRandom random)
        throws InvalidKeyException
    {
        try
        {
            initEncrypt(keynullrandom);
        }
        catch (InvalidAlgorithmParameterException iape)
        {
            throw new InvalidParameterException(
                "This cipher needs algorithm parameters for initialization (cannot be null).");
        }
    }

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

Parameters:
key the encryption 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 algorithm parameters are inappropriate for this cipher, or if this cipher is initialized with null parameters and cannot generate parameters itself.
    public final void initEncrypt(Key keyAlgorithmParameterSpec params)
    {
        initEncrypt(keyparamsnew SecureRandom());
    }

    
Initialize the cipher with a certain key for data encryption.

If this cipher 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.

Parameters:
key the encryption key
random 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 initialized with null parameters and cannot generate parameters itself.
    public final void initEncrypt(Key keyAlgorithmParameterSpec params,
                                  SecureRandom random)
        throws InvalidKeyException,
    {
         = ;
        initCipherEncrypt(keyparamsrandom);
    }

    
Initialize the cipher for decryption by forwarding it to initDecrypt(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 getParameters().

Parameters:
key the decryption key
Throws:
java.security.InvalidKeyException if the given key is inappropriate for initializing this cipher.
    public final void initDecrypt(Key key)
        throws InvalidKeyException
    {
        try
        {
            initDecrypt(keynull);
        }
        catch (InvalidAlgorithmParameterException iape)
        {
            throw new InvalidParameterException(
                "This cipher needs algorithm parameters for initialization (cannot be null).");
        }
    }

    
Initialize the cipher with a certain key for data decryption.

If this cipher 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

Parameters:
key the 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 algorithm parameters are inappropriate for this cipher, or if this cipher is initialized with null parameters and cannot generate parameters itself.
    public final void initDecrypt(Key keyAlgorithmParameterSpec params)
    {
         = ;
        initCipherDecrypt(keyparams);
    }

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

Parameters:
input the input buffer
inOff the offset where the input starts
inLen the input length
Returns:
a new buffer with the result (maybe an empty byte array)
    public abstract byte[] update(byte[] inputint inOffint inLen);

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

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
Throws:
javax.crypto.ShortBufferException if the output buffer is too small to hold the result.
    public final int update(byte[] inputint inOffint inLenbyte[] output,
                            int outOff)
        throws ShortBufferException
    {
        if (output.length < getOutputSize(inLen))
        {
            throw new ShortBufferException("output");
        }
        byte[] out = update(inputinOffinLen);
        System.arraycopy(out, 0, outputoutOffout.length);
        return out.length;
    }

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

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.BadPaddingException if the ciphertext is invalid.
    public abstract byte[] doFinal(byte[] inputint inOffint inLen)
        throws BadPaddingException;

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

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.BadPaddingException if the ciphertext is invalid.
    public final int doFinal(byte[] inputint inOffint inLenbyte[] output,
                             int outOff)
    {
        if (output.length < getOutputSize(inLen))
        {
            throw new ShortBufferException("Output buffer too short.");
        }
        byte[] out = doFinal(inputinOffinLen);
        System.arraycopy(out, 0, outputoutOffout.length);
        return out.length;
    }

    
Compute the output size of an update() or doFinal() operation of a hybrid asymmetric cipher in encryption mode when given input of the specified length.

Parameters:
inLen the length of the input
Returns:
the output size
    protected abstract int encryptOutputSize(int inLen);

    
Compute the output size of an update() or doFinal() operation of a hybrid asymmetric cipher in decryption mode when given input of the specified length.

Parameters:
inLen the length of the input
Returns:
the output size
    protected abstract int decryptOutputSize(int inLen);

    
Initialize the AsymmetricHybridCipher 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.
    protected abstract void initCipherEncrypt(Key key,
                                              AlgorithmParameterSpec paramsSecureRandom sr)
Initialize the AsymmetricHybridCipher 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.
    protected abstract void initCipherDecrypt(Key key,
                                              AlgorithmParameterSpec params)
        throws InvalidKeyException,
New to GrepCode? Check out our FAQ X