JCEStreamCipherpublic class JCEStreamCipher extends WrapCipherSpi implements PBE
| Fields Summary |
|---|
| private Class[] | availableSpecs | | private org.bouncycastle.crypto.StreamCipher | cipher | | private org.bouncycastle.crypto.params.ParametersWithIV | ivParam | | private int | ivLength | | private PBEParameterSpec | pbeSpec | | private String | pbeAlgorithm |
| Methods Summary |
|---|
| protected byte[] | engineDoFinal(byte[] input, int inputOffset, int inputLen)
if (inputLen != 0)
{
byte[] out = engineUpdate(input, inputOffset, inputLen);
cipher.reset();
return out;
}
cipher.reset();
return new byte[0];
| | protected int | engineDoFinal(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset)
if (inputLen != 0)
{
cipher.processBytes(input, inputOffset, inputLen, output, outputOffset);
}
cipher.reset();
return inputLen;
| | protected int | engineGetBlockSize()
return 0;
| | protected byte[] | engineGetIV()
return (ivParam != null) ? ivParam.getIV() : null;
| | protected int | engineGetKeySize(java.security.Key key)
return key.getEncoded().length * 8;
| | protected int | engineGetOutputSize(int inputLen)
return inputLen;
| | protected java.security.AlgorithmParameters | engineGetParameters()
if (engineParams == null)
{
if (pbeSpec != null)
{
try
{
AlgorithmParameters engineParams = AlgorithmParameters.getInstance(pbeAlgorithm, "BC");
engineParams.init(pbeSpec);
return engineParams;
}
catch (Exception e)
{
return null;
}
}
}
return engineParams;
| | protected void | engineInit(int opmode, java.security.Key key, java.security.spec.AlgorithmParameterSpec params, java.security.SecureRandom random)
CipherParameters param;
this.pbeSpec = null;
this.pbeAlgorithm = null;
this.engineParams = null;
//
// basic key check
//
if (!(key instanceof SecretKey))
{
throw new InvalidKeyException("Key for algorithm " + key.getAlgorithm() + " not suitable for symmetric enryption.");
}
if (key instanceof JCEPBEKey)
{
JCEPBEKey k = (JCEPBEKey)key;
if (k.getOID() != null)
{
pbeAlgorithm = k.getOID().getId();
}
else
{
pbeAlgorithm = k.getAlgorithm();
}
if (k.getParam() != null)
{
param = k.getParam();
pbeSpec = new PBEParameterSpec(k.getSalt(), k.getIterationCount());
}
else if (params instanceof PBEParameterSpec)
{
param = PBE.Util.makePBEParameters(k, params, cipher.getAlgorithmName());
pbeSpec = (PBEParameterSpec)params;
}
else
{
throw new InvalidAlgorithmParameterException("PBE requires PBE parameters to be set.");
}
if (k.getIvSize() != 0)
{
ivParam = (ParametersWithIV)param;
}
}
else if (params == null)
{
param = new KeyParameter(key.getEncoded());
}
else if (params instanceof IvParameterSpec)
{
param = new ParametersWithIV(new KeyParameter(key.getEncoded()), ((IvParameterSpec)params).getIV());
ivParam = (ParametersWithIV)param;
}
else
{
throw new IllegalArgumentException("unknown parameter type.");
}
if ((ivLength != 0) && !(param instanceof ParametersWithIV))
{
SecureRandom ivRandom = random;
if (ivRandom == null)
{
ivRandom = new SecureRandom();
}
if ((opmode == Cipher.ENCRYPT_MODE) || (opmode == Cipher.WRAP_MODE))
{
byte[] iv = new byte[ivLength];
ivRandom.nextBytes(iv);
param = new ParametersWithIV(param, iv);
ivParam = (ParametersWithIV)param;
}
else
{
throw new InvalidAlgorithmParameterException("no IV set when one expected");
}
}
switch (opmode)
{
case Cipher.ENCRYPT_MODE:
case Cipher.WRAP_MODE:
cipher.init(true, param);
break;
case Cipher.DECRYPT_MODE:
case Cipher.UNWRAP_MODE:
cipher.init(false, param);
break;
default:
System.out.println("eeek!");
}
| | protected void | engineInit(int opmode, java.security.Key key, java.security.AlgorithmParameters params, java.security.SecureRandom random)
AlgorithmParameterSpec paramSpec = null;
if (params != null)
{
for (int i = 0; i != availableSpecs.length; i++)
{
try
{
paramSpec = params.getParameterSpec(availableSpecs[i]);
break;
}
catch (Exception e)
{
continue;
}
}
if (paramSpec == null)
{
throw new InvalidAlgorithmParameterException("can't handle parameter " + params.toString());
}
}
engineInit(opmode, key, paramSpec, random);
engineParams = params;
| | protected void | engineInit(int opmode, java.security.Key key, java.security.SecureRandom random)
try
{
engineInit(opmode, key, (AlgorithmParameterSpec)null, random);
}
catch (InvalidAlgorithmParameterException e)
{
throw new InvalidKeyException(e.getMessage());
}
| | protected void | engineSetMode(java.lang.String mode)should never be called.
if (!mode.equalsIgnoreCase("ECB"))
{
throw new IllegalArgumentException("can't support mode " + mode);
}
| | protected void | engineSetPadding(java.lang.String padding)should never be called.
if (!padding.equalsIgnoreCase("NoPadding"))
{
throw new NoSuchPaddingException("Padding " + padding + " unknown.");
}
| | protected byte[] | engineUpdate(byte[] input, int inputOffset, int inputLen)
byte[] out = new byte[inputLen];
cipher.processBytes(input, inputOffset, inputLen, out, 0);
return out;
| | protected int | engineUpdate(byte[] input, int inputOffset, int inputLen, byte[] output, int outputOffset)
try
{
cipher.processBytes(input, inputOffset, inputLen, output, outputOffset);
return inputLen;
}
catch (DataLengthException e)
{
throw new ShortBufferException(e.getMessage());
}
|
|
