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:
- The key size is taken from the encoded form of the key passed to
initEncrypt
or initDecrypt
. It can be
any even number of bytes from 6 to 32 (6, 8, 10, ... 32).
- The length of the data block defaults to the value of the parameter
"Alg.blockSize.SPEED", or 8 bytes (c.f. IDEA and DES) if that parameter
is not found.
It can be set by calling setBlockSize(), and can be 8, 16, or 32 bytes.
- The number of rounds defaults to the value of the parameter
"Alg.rounds.SPEED", or 64 (which gives 'adequate' security according
to the paper below) if that parameter is not found.
It can be set by calling setRounds(), and can be any number from 32
upwards, divisible by 4 (32, 36, ...).
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:
- 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.6 $
blockDecrypt
protected void blockDecrypt(in[] ,
int in_offset,
out[] ,
int out_offset)
Decrypts a block. The in and out buffers can be the same.
in_offset
- The start of data within the in buffer.out_offset
- The start of data within the out buffer.
blockEncrypt
protected void blockEncrypt(in[] ,
int in_offset,
out[] ,
int out_offset)
Encrypts a block. The in and out buffers can be the same.
in_offset
- The start of data within the in buffer.out_offset
- The start of data within the out buffer.
clone
public final Object clone()
throws CloneNotSupportedException
Always throws a CloneNotSupportedException (cloning of ciphers is not
supported for security reasons).
- clone in interface Cipher
dump
(package private) void dump()
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.
- engineBlockSize in interface Cipher
- the block length in bytes.
engineGetParameter
protected Object engineGetParameter(String param)
throws NoSuchParameterException,
InvalidParameterException
SPI: Gets the value of the specified algorithm parameter.
SPEED has two parameters:
- "rounds", which specifies the number of rounds for this instance
as a decimal String.
- "blockSize", which specifies the block size for this instance,
also as a decimal String.
- engineGetParameter in interface Cipher
param
- the string name of the parameter.
- the object that represents the parameter value, or null if there
is none.
engineInitDecrypt
public void engineInitDecrypt(Key key)
throws InvalidKeyException,
CryptixException
SPI: Initializes this cipher for decryption, using the
specified key.
- engineInitDecrypt in interface Cipher
key
- the key to use for decryption.
engineInitEncrypt
public void engineInitEncrypt(Key key)
throws InvalidKeyException
SPI: Initializes this cipher for encryption, using the
specified key.
- engineInitEncrypt in interface Cipher
key
- the key to use for encryption.
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:
- "rounds", which specifies the number of rounds for this instance
as a decimal String.
- "blockSize", which specifies the block size for this instance,
also as a decimal String.
- engineSetParameter in interface Cipher
param
- the string name of the parameter.value
- the parameter value.
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.
- engineUpdate in interface Cipher
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.
- the number of bytes written.
finalize
protected final void finalize()
Cleans up resources used by this instance, if necessary.
getLinkStatus
public static LinkStatus getLinkStatus()
Gets an object representing the native linking status of this class.
getRounds
public int getRounds()
Returns the currently set number of rounds for this instance.
main
public static final void main(argv[] )
Entry point for self_test.
self_test
public static void self_test(PrintWriter out,
argv[] )
throws Exception
Runs algorithm through test data, including certification data
provided in paper.
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.
blocksize
- the desired block size in bytes: 8, 16 or 32
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.
rounds
- the desired number of rounds: >= 32, multiple of 4