net.i2p.crypto

## Class HMACGenerator

- java.lang.Object
- - net.i2p.crypto.HMACGenerator

- Direct Known Subclasses:
    HMAC256Generator

      public abstract class HMACGenerator
      extends Object

  Abstract base class for HMAC (Hash-based Message Authentication Code) operations. This class provides the foundation for HMAC algorithm implementations used throughout I2P for message authentication and integrity verification. It defines the standard interface for calculating and verifying HMAC values with various hash algorithms.

  Key operations include:

  - HMAC calculation with given key and message data
  - Inline MAC verification for performance optimization
  - Support for different hash algorithms (SHA-1, SHA-256)
  - Integration with I2P's session key management

  Implementation Note: As of 0.9.42, this class serves as an abstract base. See `net.i2p.router.transport.udp.SSUHMACGenerator` for SSU-specific HMAC implementation and `SHA256Generator` for Syndie-compatible HMAC operations.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `HMACGenerator()`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected byte[]` | `acquireTmp()` 32 bytes from the byte array cache.
    `abstract void` | `calculate(SessionKey key, byte[] data, int offset, int length, byte[] target, int targetOffset)` Calculate the HMAC of the data with the given key
    `protected void` | `releaseTmp(byte[] tmp)`
    `abstract boolean` | `verify(SessionKey key, byte[] curData, int curOffset, int curLength, byte[] origMAC, int origMACOffset, int origMACLength)` Verify the MAC inline, reducing some unnecessary memory churn.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### HMACGenerator

          public HMACGenerator()

  - ### Method Detail

    - #### acquireTmp

          protected byte[] acquireTmp()

      32 bytes from the byte array cache. Does NOT zero.

    - #### calculate

          public abstract void calculate(SessionKey key,
                                         byte[] data,
                                         int offset,
                                         int length,
                                         byte[] target,
                                         int targetOffset)

      Calculate the HMAC of the data with the given key
      Parameters:
        `key` - the session key
        `data` - the data to HMAC
        `offset` - the starting offset in data
        `length` - the length of data to HMAC
        `target` - out parameter the first 16 bytes contain the HMAC, the last 16 bytes are zero
        `targetOffset` - offset into target to put the hmac
      Throws:
        `IllegalArgumentException` - for bad key or target too small

    - #### releaseTmp

          protected void releaseTmp(byte[] tmp)

    - #### verify

          public abstract boolean verify(SessionKey key,
                                         byte[] curData,
                                         int curOffset,
                                         int curLength,
                                         byte[] origMAC,
                                         int origMACOffset,
                                         int origMACLength)

      Verify the MAC inline, reducing some unnecessary memory churn.
      Parameters:
        `key` - session key to verify the MAC with
        `curData` - MAC to verify
        `curOffset` - index into curData to MAC
        `curLength` - how much data in curData do we want to run the HMAC over
        `origMAC` - what do we expect the MAC of curData to equal
        `origMACOffset` - index into origMAC
        `origMACLength` - how much of the MAC do we want to verify
      Throws:
        `IllegalArgumentException` - for bad key