diff options
Diffstat (limited to 'libjava/classpath/gnu/javax/crypto/pad/BasePad.java')
| -rw-r--r-- | libjava/classpath/gnu/javax/crypto/pad/BasePad.java | 148 |
1 files changed, 93 insertions, 55 deletions
diff --git a/libjava/classpath/gnu/javax/crypto/pad/BasePad.java b/libjava/classpath/gnu/javax/crypto/pad/BasePad.java index 49c5d050a85..8b475d2d8cb 100644 --- a/libjava/classpath/gnu/javax/crypto/pad/BasePad.java +++ b/libjava/classpath/gnu/javax/crypto/pad/BasePad.java @@ -38,24 +38,24 @@ exception statement from your version. */ package gnu.javax.crypto.pad; +import gnu.java.security.Configuration; + +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; + /** - * <p>An abstract class to facilitate implementing padding algorithms.</p> + * An abstract class to facilitate implementing padding algorithms. */ -public abstract class BasePad implements IPad +public abstract class BasePad + implements IPad { - - // Constants and variables - // ------------------------------------------------------------------------- - + private static final Logger log = Logger.getLogger(BasePad.class.getName()); /** The canonical name prefix of the padding algorithm. */ protected String name; - /** The block size, in bytes, for this instance. */ protected int blockSize; - // Constructor(s) - // ------------------------------------------------------------------------- - /** Trivial constructor for use by concrete subclasses. */ protected BasePad(final String name) { @@ -65,84 +65,122 @@ public abstract class BasePad implements IPad blockSize = -1; } - // Class methods - // ------------------------------------------------------------------------- - - // Instance methods - // ------------------------------------------------------------------------- - - // IPad interface implementation ------------------------------------------- - public String name() { final StringBuffer sb = new StringBuffer(name); if (blockSize != -1) - { - sb.append('-').append(String.valueOf(8 * blockSize)); - } + sb.append('-').append(String.valueOf(8 * blockSize)); return sb.toString(); } public void init(final int bs) throws IllegalStateException { if (blockSize != -1) - { - throw new IllegalStateException(); - } + throw new IllegalStateException(); blockSize = bs; setup(); } + /** + * Initialises the algorithm with designated attributes. Names, valid and/or + * recognisable by all concrete implementations are described in {@link IPad} + * class documentation. Other algorithm-specific attributes MUST be documented + * in the implementation class of that padding algorithm. + * <p> + * For compatibility reasons, this method is not declared <i>abstract</i>. + * 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 <code>true</code> if the concrete implementation correctly unpads + * what it pads for all tested block sizes. Returns <code>false</code> + * 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. + * <p> + * 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 <code>true</code> if the test passes; <code>false</code> + * otherwise. + */ + protected boolean test1BlockSize(int size, byte[] buffer) + { byte[] padBytes; final int offset = 5; - final int limit = 1024; - final byte[] in = new byte[limit]; - for (int bs = 2; bs < 256; bs++) + final int limit = buffer.length; + this.init(size); + for (int i = 0; i < limit - offset - blockSize; i++) { - this.init(bs); - for (int i = 0; i < limit - offset - blockSize; i++) + padBytes = pad(buffer, offset, i); + if (((i + padBytes.length) % blockSize) != 0) { - padBytes = pad(in, offset, i); - if (((i + padBytes.length) % blockSize) != 0) - { - new RuntimeException(name()).printStackTrace(System.err); - return false; - } - - System.arraycopy(padBytes, 0, in, offset + i, padBytes.length); - try - { - if (padBytes.length != unpad(in, offset, i + padBytes.length)) - { - new RuntimeException(name()).printStackTrace(System.err); - return false; - } - } - catch (WrongPaddingException x) + 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)) { - x.printStackTrace(System.err); + if (Configuration.DEBUG) + log.log(Level.SEVERE, + "IPad [" + name() + "] failed symmetric operation", + new RuntimeException(name())); return false; } } - this.reset(); + catch (WrongPaddingException x) + { + if (Configuration.DEBUG) + log.throwing(this.getClass().getName(), "test1BlockSize", x); + return false; + } } - + this.reset(); return true; } - // abstract methods to implement by subclasses ----------------------------- - /** - * <p>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.</p> + * 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(); @@ -150,4 +188,4 @@ public abstract class BasePad implements IPad public abstract int unpad(byte[] in, int off, int len) throws WrongPaddingException; -}
\ No newline at end of file +} |