Implementation note: this class is present for
* API-compatibility only; it is not actually used anywhere in this library
* and this library does not, in general, support crypto weakening.
*
* @author Casey Marshall (csm@gnu.org)
* @since 1.4
*/
public class ExemptionMechanism
{
// Constants and fields.
// ------------------------------------------------------------------------
private static final String SERVICE = "ExemptionMechanism";
private ExemptionMechanismSpi emSpi;
private Provider provider;
private String mechanism;
private boolean virgin;
// Constructor.
// ------------------------------------------------------------------------
protected ExemptionMechanism(ExemptionMechanismSpi emSpi, Provider provider,
String mechanism)
{
this.emSpi = emSpi;
this.provider = provider;
this.mechanism = mechanism;
virgin = true;
}
/**
* Create an instance of ExemptionMechanism for a designated
* mechanism from the first Security Provider offering it.
*
* @param mechanism the name of the exemption mechanism to create.
* @return a newly created instance of ExemptionMechanism.
* @throws IllegalArgumentException if the provider is null.
* @throws NoSuchAlgorithmException if no such exemption mechanism is
* available from any known Security Provider.
* @throws IllegalArgumentException if mechanism is
* null or is an empty string.
*/
public static final ExemptionMechanism getInstance(String mechanism)
throws NoSuchAlgorithmException
{
Provider[] p = Security.getProviders();
NoSuchAlgorithmException lastException = null;
for (int i = 0; i < p.length; i++)
try
{
return getInstance(mechanism, p[i]);
}
catch (NoSuchAlgorithmException x)
{
lastException = x;
}
if (lastException != null)
throw lastException;
throw new NoSuchAlgorithmException(mechanism);
}
/**
* Create an instance of ExemptionMechanism for a designated
* mechanism from a named provider.
*
* @param mechanism the name of the exemption mechanism to create.
* @param provider the security provider to provide the exemption
* mechanism.
* @return a newly created instance of ExemptionMechanism.
* @throws NoSuchAlgorithmException if no such exemption mechanism is
* available from the named provider.
* @throws NoSuchProviderException if no Security Provider with the designated
* name is known to the underlying JVM.
* @throws IllegalArgumentException if either mechanism or
* provider is null, or if
* mechanism is an empty string.
*/
public static final ExemptionMechanism getInstance(String mechanism,
String provider)
throws NoSuchAlgorithmException, NoSuchProviderException
{
if (provider == null)
throw new IllegalArgumentException("provider MUST NOT be null");
Provider p = Security.getProvider(provider);
if (p == null)
throw new NoSuchProviderException(provider);
return getInstance(mechanism, p);
}
/**
* Create an instance of ExemptionMechanism for a designated
* mechanism from a designated provider.
*
* @param mechanism the name of the exemption mechanism to create.
* @param provider the security provider to provide the exemption
* mechanism.
* @return a newly created instance of ExemptionMechanism.
* @throws NoSuchAlgorithmException if an exemption mechanism could not be
* created.
* @throws IllegalArgumentException if either mechanism or
* provider is null, or if
* mechanism is an empty string.
*/
public static final ExemptionMechanism getInstance(String mechanism,
Provider provider)
throws NoSuchAlgorithmException
{
StringBuilder sb = new StringBuilder("ExemptionMechanism [")
.append(mechanism).append("] from provider[")
.append(provider).append("] could not be created");
Throwable cause;
try
{
Object spi = Engine.getInstance(SERVICE, mechanism, provider);
return new ExemptionMechanism((ExemptionMechanismSpi) spi,
provider,
mechanism);
}
catch (InvocationTargetException x)
{
cause = x.getCause();
if (cause instanceof NoSuchAlgorithmException)
throw (NoSuchAlgorithmException) cause;
if (cause == null)
cause = x;
}
catch (ClassCastException x)
{
cause = x;
}
NoSuchAlgorithmException x = new NoSuchAlgorithmException(sb.toString());
x.initCause(cause);
throw x;
}
public final byte[] genExemptionBlob()
throws IllegalStateException, ExemptionMechanismException
{
if (virgin)
{
throw new IllegalStateException("not initialized");
}
return emSpi.engineGenExemptionBlob();
}
public final int genExemptionBlob(byte[] output)
throws IllegalStateException, ExemptionMechanismException,
ShortBufferException
{
return genExemptionBlob(output, 0);
}
public final int genExemptionBlob(byte[] output, int outputOffset)
throws IllegalStateException, ExemptionMechanismException,
ShortBufferException
{
if (virgin)
{
throw new IllegalStateException("not initialized");
}
return emSpi.engineGenExemptionBlob(output, outputOffset);
}
public final String getName()
{
return mechanism;
}
public final int getOutputSize(int inputLength) throws IllegalStateException
{
if (virgin)
{
throw new IllegalStateException("not initialized");
}
return emSpi.engineGetOutputSize(inputLength);
}
public final Provider getProvider()
{
return provider;
}
public final void init(Key key)
throws ExemptionMechanismException, InvalidKeyException
{
emSpi.engineInit(key);
virgin = false;
}
public final void init(Key key, AlgorithmParameters params)
throws ExemptionMechanismException, InvalidAlgorithmParameterException,
InvalidKeyException
{
emSpi.engineInit(key, params);
virgin = false;
}
public final void init(Key key, AlgorithmParameterSpec params)
throws ExemptionMechanismException, InvalidAlgorithmParameterException,
InvalidKeyException
{
emSpi.engineInit(key, params);
virgin = false;
}
public final boolean isCryptoAllowed(Key key)
throws ExemptionMechanismException
{
return true;
}
protected void finalize()
{
}
}