All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class cryptix.provider.cipher.SPEED

java.lang.Object
   |
   +----java.security.IJCE_Traceable
           |
           +----java.security.Cipher
                   |
                   +----cryptix.provider.cipher.SPEED

public final class SPEED
extends Cipher
implements SymmetricCipher
SPEED is a block cipher with variable key size, data block size and number of rounds (in the style of RC5).

These parameters are set as follows:

These are recommended settings for 'adequate' security:

    +--------------------------------------------------+
    |   block size   |   key length   |     rounds     |
    |==================================================|
    |       8        |      >= 8      |     >= 64      |
    |--------------------------------------------------|
    |      16        |      >= 8      |     >= 48      |
    |--------------------------------------------------|
    |      32        |      >= 8      |     >= 48      |
    +--------------------------------------------------+
 

SPEED was designed by Yuliang Zheng, and is in the public domain.

References:

  1. Y. Zheng "The SPEED Cipher," Proceedings of Financial Cryptography 97, Springer-Verlag (forthcoming). FC97 held at Anguilla, BWI, 24-28 February 1997.

Copyright © 1997 Systemics Ltd on behalf of the Cryptix Development Team.
All rights reserved.

$Revision: 1.5 $

Author:
Systemics Ltd, David Hopwood

Constructor Index

 o SPEED()
Constructs a SPEED cipher object, in the UNINITIALIZED state.

Method Index

 o blockDecrypt(byte[], int, byte[], int)
Decrypts a block.
 o blockEncrypt(byte[], int, byte[], int)
Encrypts a block.
 o clone()
Always throws a CloneNotSupportedException (cloning of ciphers is not supported for security reasons).
 o engineBlockSize()
SPI: Return the data block length of this cipher.
 o engineGetParameter(String)
SPI: Gets the value of the specified algorithm parameter.
 o engineInitDecrypt(Key)
SPI: Initializes this cipher for decryption, using the specified key.
 o engineInitEncrypt(Key)
SPI: Initializes this cipher for encryption, using the specified key.
 o engineSetParameter(String, Object)
SPI: Sets the specified algorithm parameter to the specified value.
 o engineUpdate(byte[], int, int, byte[], int)
SPI: This is the main engine method for updating data.
 o finalize()
Cleans up resources used by this instance, if necessary.
 o getLinkStatus()
Gets an object representing the native linking status of this class.
 o getRounds()
Returns the currently set number of rounds for this instance.
 o main(String[])
Entry point for self_test.
 o self_test(PrintWriter, String[])
Runs algorithm through test data, including certification data provided in paper.
 o setBlockSize(int)
Sets the block size in bytes for this cipher.
 o setRounds(int)
Sets the number of rounds for this cipher.

Constructors

 o SPEED
 public SPEED()
Constructs a SPEED cipher object, in the UNINITIALIZED state. This calls the Cipher constructor with implBuffering false, implPadding false and the provider set to "Cryptix".

Methods

 o getLinkStatus
 public static LinkStatus getLinkStatus()
Gets an object representing the native linking status of this class.

 o finalize
 protected final void finalize()
Cleans up resources used by this instance, if necessary.

Overrides:
finalize in class Object
 o clone
 public final Object clone() throws CloneNotSupportedException
Always throws a CloneNotSupportedException (cloning of ciphers is not supported for security reasons).

Overrides:
clone in class Cipher
 o engineBlockSize
 protected int engineBlockSize()
SPI: Return the data block length of this cipher. Default (8 bytes) is returned before instantiation, actual length used by object returned after instantiation.

Returns:
the block length in bytes.
Overrides:
engineBlockSize in class Cipher
 o engineInitEncrypt
 public void engineInitEncrypt(Key key) throws InvalidKeyException
SPI: Initializes this cipher for encryption, using the specified key.

Parameters:
key - the key to use for encryption.
Throws: InvalidKeyException
if one of the following occurs:
  • key.getEncoded() == null;
  • The length of the user key array is not ...
Overrides:
engineInitEncrypt in class Cipher
 o engineInitDecrypt
 public void engineInitDecrypt(Key key) throws InvalidKeyException, CryptixException
SPI: Initializes this cipher for decryption, using the specified key.

Parameters:
key - the key to use for decryption.
Throws: InvalidKeyException
if one of the following occurs:
  • key.getEncoded() == null;
  • The length of the user key array is not ...
Overrides:
engineInitDecrypt in class Cipher
 o engineUpdate
 protected int engineUpdate(byte in[],
                            int inOffset,
                            int inLen,
                            byte out[],
                            int outOffset)
SPI: This is the main engine method for updating data.

in and out may be the same array, and the input and output regions may overlap.

Parameters:
in - the input data.
inOffset - the offset into in specifying where the data starts.
inLen - the length of the subarray.
out - the output array.
outOffset - the offset indicating where to start writing into the out array.
Returns:
the number of bytes written.
Throws: CryptixException
if the native library is being used, and it reports an error.
Overrides:
engineUpdate in class Cipher
 o engineSetParameter
 protected void engineSetParameter(String param,
                                   Object value) throws NoSuchParameterException, InvalidParameterException, InvalidParameterTypeException
SPI: Sets the specified algorithm parameter to the specified value.

SPEED has two parameters:

Parameters:
param - the string name of the parameter.
value - the parameter value.
Throws: InvalidParameterException
if param is an invalid parameter for this cipher implementation, the parameter is already set and cannot be set again, a security exception occurs, and so on.
Throws: InvalidParameterTypeException
if value is of the wrong type.
Overrides:
engineSetParameter in class Cipher
 o engineGetParameter
 protected Object engineGetParameter(String param) throws NoSuchParameterException, InvalidParameterException
SPI: Gets the value of the specified algorithm parameter.

SPEED has two parameters:

Parameters:
param - the string name of the parameter.
Returns:
the object that represents the parameter value, or null if there is none.
Overrides:
engineGetParameter in class Cipher
 o setRounds
 public void setRounds(int rounds)
Sets the number of rounds for this cipher. Allowed only when this cipher is in the UNINITIALIZED state; otherwise an exception is thrown.

If the specified number is invalid, an IllegalArgumentException is thrown.

Parameters:
rounds - the desired number of rounds: >= 32, multiple of 4
Throws: IllegalStateException
if this cipher is not uninitialised.
Throws: InvalidParameterException
if the given number of rounds is not supported.
 o getRounds
 public int getRounds()
Returns the currently set number of rounds for this instance.

Returns:
the number of rounds.
 o setBlockSize
 public void setBlockSize(int blocksize)
Sets the block size in bytes for this cipher. Allowed only when this cipher is in the UNINITIALIZED state; otherwise an exception is thrown.

If the specified number is invalid, an IllegalArgumentException is thrown.

Parameters:
blocksize - the desired block size in bytes: 8, 16 or 32
Throws: IllegalStateException
if this cipher is not uninitialised.
Throws: IllegalArgumentException
if the given number of rounds is not supported.
 o blockEncrypt
 protected void blockEncrypt(byte in[],
                             int in_offset,
                             byte out[],
                             int out_offset)
Encrypts a block. The in and out buffers can be the same.

Parameters:
in - The data to be encrypted.
in_offset - The start of data within the in buffer.
out - The encrypted data.
out_offset - The start of data within the out buffer.
 o blockDecrypt
 protected void blockDecrypt(byte in[],
                             int in_offset,
                             byte out[],
                             int out_offset)
Decrypts a block. The in and out buffers can be the same.

Parameters:
in - The data to be decrypted.
in_offset - The start of data within the in buffer.
out - The decrypted data.
out_offset - The start of data within the out buffer.
 o main
 public static final void main(String argv[])
Entry point for self_test.

 o self_test
 public static void self_test(PrintWriter out,
                              String argv[]) throws Exception
Runs algorithm through test data, including certification data provided in paper.


All Packages  Class Hierarchy  This Package  Previous  Next  Index