* For compatibility reasons, this method is not declared abstract.
* Furthermore, and unless overridden, the default implementation will throw
* an {@link UnsupportedOperationException}. Concrete padding algorithms MUST
* override this method if they wish to offer an initialisation method that
* allows for other than the padding block size parameter to be specified.
*
* @param attributes a set of name-value pairs that describes the desired
* future behaviour of this instance.
* @exception IllegalStateException if the instance is already initialised.
* @exception IllegalArgumentException if the block size value is invalid.
*/
public void init(Map attributes) throws IllegalStateException
{
throw new UnsupportedOperationException();
}
public void reset()
{
blockSize = -1;
}
/**
* A default implementation of a correctness test that exercises the padder
* implementation, using block sizes varying from 2 to 256 bytes.
*
* @return true if the concrete implementation correctly unpads
* what it pads for all tested block sizes. Returns false
* if the test fails for any block size.
*/
public boolean selfTest()
{
final byte[] in = new byte[1024];
for (int bs = 2; bs < 256; bs++)
if (! test1BlockSize(bs, in))
return false;
return true;
}
/**
* The basic symmetric test for a padder given a specific block size.
*
* The code ensures that the implementation is capable of unpadding what it
* pads.
*
* @param size the block size to test.
* @param buffer a work buffer. It is exposed as an argument for this method
* to reduce un-necessary object allocations.
* @return true if the test passes; false
* otherwise.
*/
protected boolean test1BlockSize(int size, byte[] buffer)
{
byte[] padBytes;
final int offset = 5;
final int limit = buffer.length;
this.init(size);
for (int i = 0; i < limit - offset - blockSize; i++)
{
padBytes = pad(buffer, offset, i);
if (((i + padBytes.length) % blockSize) != 0)
{
if (Configuration.DEBUG)
log.log(Level.SEVERE,
"Length of padded text MUST be a multiple of "
+ blockSize, new RuntimeException(name()));
return false;
}
System.arraycopy(padBytes, 0, buffer, offset + i, padBytes.length);
try
{
if (padBytes.length != unpad(buffer, offset, i + padBytes.length))
{
if (Configuration.DEBUG)
log.log(Level.SEVERE,
"IPad [" + name() + "] failed symmetric operation",
new RuntimeException(name()));
return false;
}
}
catch (WrongPaddingException x)
{
if (Configuration.DEBUG)
log.throwing(this.getClass().getName(), "test1BlockSize", x);
return false;
}
}
this.reset();
return true;
}
/**
* If any additional checks or resource setup must be done by the subclass,
* then this is the hook for it. This method will be called before the
* {@link #init(int)} method returns.
*/
public abstract void setup();
public abstract byte[] pad(byte[] in, int off, int len);
public abstract int unpad(byte[] in, int off, int len)
throws WrongPaddingException;
}