Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## javacard.framework.security
Class Checksum

    java.lang.Object
      javacard.framework.security.Checksum

Direct Known Subclasses:
  CRC16, CRC32

    public abstract class Checksum

extends Object

The `Checksum` class is the base class for CRC (cyclic redundancy check) checksum algorithms. Implementations of Checksum algorithms must extend this class and implement all the abstract methods.

A tear or card reset event resets a `Checksum` object to the initial state (state upon construction).

Even if a transaction is in progress, update of intermediate result state in the implementation instance shall not participate in the transaction.

Field Summary
`static byte` | `ALG_ISO3309_CRC16` ISO/IEC 3309 compliant 16 bit CRC algorithm.
`static byte` | `ALG_ISO3309_CRC32` ISO/IEC 3309 compliant 32 bit CRC algorithm.

Constructor Summary
`protected` | `Checksum()` Protected Constructor

Method Summary
`abstract short` | `doFinal(byte[] inBuff, short inOffset, short inLength, byte[] outBuff, short outOffset)` Generates a CRC checksum of all/last input data.
`abstract byte` | `getAlgorithm()` Gets the Checksum algorithm.
`static Checksum` | `getInstance(byte algorithm, boolean externalAccess)` Creates a `Checksum` object instance of the selected algorithm.
`abstract void` | `init(byte[] bArray, short bOff, short bLen)` Resets and initializes the `Checksum` object with the algorithm specific Note: The ALG_ISO3309_CRC16 algorithm expects 2 bytes of parameter information in `bArray` representing the initial checksum value.
`abstract void` | `update(byte[] inBuff, short inOffset, short inLength)` Accumulates a partial checksum of the input data.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### ALG_ISO3309_CRC16

    public static final byte ALG_ISO3309_CRC16

  ISO/IEC 3309 compliant 16 bit CRC algorithm.

  See Also:
    Constant Field Values

### ALG_ISO3309_CRC32

    public static final byte ALG_ISO3309_CRC32

  ISO/IEC 3309 compliant 32 bit CRC algorithm.

  See Also:
    Constant Field Values

Constructor Detail

### Checksum

    protected Checksum()

  Protected Constructor

Method Detail

### getInstance

    public static final Checksum getInstance(byte algorithm,
                                             boolean externalAccess)
                                      throws CryptoException

  Creates a `Checksum` object instance of the selected algorithm.

  Parameters:
    `algorithm` - the desired checksum algorithm.
    `externalAccess` - `true` indicates that the instance will be shared among multiple applet instances and that the `Checksum` instance will also be accessed (via a `Shareable`. interface) when the owner of the `Checksum` instance is not the currently selected applet. If `true` the implementation must not allocate CLEAR_ON_DESELECT transient space for internal data.
  Returns:
    the `Checksum` object instance of the requested algorithm.
  Throws:
    `CryptoException` - with the following reason codes:
    - `CryptoException.NO_SUCH_ALGORITHM` if the requested algorithm or shared access mode is not supported.

### getAlgorithm

    public abstract byte getAlgorithm()

  Gets the Checksum algorithm. Valid codes listed in ALG_ .. constants above, for example, `ALG_ISO3309_CRC16`

  Returns:
    the algorithm code defined above

### init

    public abstract void init(byte[] bArray,
                              short bOff,
                              short bLen)
                       throws CryptoException

  Resets and initializes the `Checksum` object with the algorithm specific

  Note:

  - The ALG_ISO3309_CRC16 algorithm expects 2 bytes of parameter information in `bArray` representing the initial checksum value.
  - The ALG_ISO3309_CRC32 algorithm expects 4 bytes of parameter information in `bArray` representing the initial checksum value.

  Parameters:
    `bArray` - byte array containing algorithm specific initialization information
    `bOff` - offset within `bArray` where the algorithm specific data begins
    `bLen` - byte length of algorithm specific parameter data.
  Throws:
    `CryptoException` - with the following reason codes:
    - `CryptoException.ILLEGAL_VALUE` if a byte array parameter option is not supported by the algorithm or if the `bLen` is an incorrect byte length for the algorithm specific data.

### doFinal

    public abstract short doFinal(byte[] inBuff,
                                  short inOffset,
                                  short inLength,
                                  byte[] outBuff,
                                  short outOffset)

  Generates a CRC checksum of all/last input data. The CRC engine processes input data starting with the byte at offset `inOffset` and continuing on until the byte at `(inOffset+inLength-1)` of the `inBuff` array. Within each byte the processing proceeds from the least significant bit to the most.

  Completes and returns the checksum computation. The `Checksum` object is reset to the initial state(state upon construction) when this method completes.

  Note:

  - The ALG_ISO3309_CRC16 and ALG_ISO3309_CRC32 algorithms reset the initial checksum value to 0. The initial checksum value can be re-initialized using the `init(byte[], short, short)` method.

  The input and output buffer data may overlap.

  Parameters:
    `inBuff` - the input buffer of data to be checksummed
    `inOffset` - the offset into the input buffer at which to begin checksum generation
    `inLength` - the byte length to checksum
    `outBuff` - the output buffer, may be the same as the input buffer
    `outOffset` - the offset into the output buffer where the resulting checksum value begins
  Returns:
    number of bytes of checksum output in `outBuff`

### update

    public abstract void update(byte[] inBuff,
                                short inOffset,
                                short inLength)

  Accumulates a partial checksum of the input data. The CRC engine processes input data starting with the byte at offset `inOffset` and continuing on until the byte at `(inOffset+inLength-1)` of the `inBuff` array. Within each byte the processing proceeds from the least significant bit to the most.

  This method requires temporary storage of intermediate results. This may result in additional resource consumption and/or slow performance. This method should only be used if all the input data required for the checksum is not available in one byte array. The `Checksum.html#doFinal(byte[], short, short, byte[], short)` `doFinal(byte[], short, short, byte[], short)` method is recommended whenever possible.

  Note:

  - If `inLength` is 0 this method does nothing.

  Parameters:
    `inBuff` - the input buffer of data to be checksummed
    `inOffset` - the offset into the input buffer at which to begin checksum generation
    `inLength` - the byte length to checksum
  See Also:
    `doFinal(byte[], short, short, byte[], short)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD