org.bouncycastle.crypto.engines

## Class NaccacheSternEngine

- java.lang.Object
- - org.bouncycastle.crypto.engines.NaccacheSternEngine

- All Implemented Interfaces:
    AsymmetricBlockCipher

      public class NaccacheSternEngine
      extends java.lang.Object
      implements AsymmetricBlockCipher

  NaccacheStern Engine. For details on this cipher, please see https://www.gemplus.com/smart/rd/publications/pdf/NS98pkcs.pdf

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `NaccacheSternEngine()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `byte[]` | `addCryptedBlocks(byte[] block1, byte[] block2)` Adds the contents of two encrypted blocks mod sigma
    `byte[]` | `encrypt(java.math.BigInteger plain)` Encrypts a BigInteger aka Plaintext with the public key.
    `int` | `getInputBlockSize()` Returns the input block size of this algorithm.
    `int` | `getOutputBlockSize()` Returns the output block size of this algorithm.
    `void` | `init(boolean forEncryption, CipherParameters param)` Initializes this algorithm.
    `byte[]` | `processBlock(byte[] in, int inOff, int len)` Process a single Block using the Naccache-Stern algorithm.
    `byte[]` | `processData(byte[] data)` Convenience Method for data exchange with the cipher.
    `void` | `setDebug(boolean debug)`

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

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

- - ### Constructor Detail

    - #### NaccacheSternEngine

          public NaccacheSternEngine()

  - ### Method Detail

    - #### init

          public void init(boolean forEncryption,
                           CipherParameters param)

      Initializes this algorithm. Must be called before all other Functions.
      Specified by:
        `init` in interface `AsymmetricBlockCipher`
      Parameters:
        `forEncryption` - if true the cipher is initialised for encryption, if false for decryption.
        `param` - the key and other data required by the cipher.
      See Also:
        `AsymmetricBlockCipher.init(boolean, org.bouncycastle.crypto.CipherParameters)`

    - #### setDebug

          public void setDebug(boolean debug)

    - #### getInputBlockSize

          public int getInputBlockSize()

      Returns the input block size of this algorithm.
      Specified by:
        `getInputBlockSize` in interface `AsymmetricBlockCipher`
      Returns:
        maximum size for an input block.
      See Also:
        `AsymmetricBlockCipher.getInputBlockSize()`

    - #### getOutputBlockSize

          public int getOutputBlockSize()

      Returns the output block size of this algorithm.
      Specified by:
        `getOutputBlockSize` in interface `AsymmetricBlockCipher`
      Returns:
        maximum size of the output block produced by the cipher.
      See Also:
        `AsymmetricBlockCipher.getOutputBlockSize()`

    - #### processBlock

          public byte[] processBlock(byte[] in,
                                     int inOff,
                                     int len)
                              throws InvalidCipherTextException

      Process a single Block using the Naccache-Stern algorithm.
      Specified by:
        `processBlock` in interface `AsymmetricBlockCipher`
      Parameters:
        `in` - the input data
        `inOff` - offset into the in array where the data starts
        `len` - the length of the block to be processed.
      Returns:
        the resulting byte array of the encryption/decryption process.
      Throws:
        `InvalidCipherTextException` - data decrypts improperly.
      See Also:
        `AsymmetricBlockCipher.processBlock(byte[], int, int)`

    - #### encrypt

          public byte[] encrypt(java.math.BigInteger plain)

      Encrypts a BigInteger aka Plaintext with the public key.
      Parameters:
        `plain` - The BigInteger to encrypt
      Returns:
        The byte[] representation of the encrypted BigInteger (i.e. crypted.toByteArray())

    - #### addCryptedBlocks

          public byte[] addCryptedBlocks(byte[] block1,
                                         byte[] block2)
                                  throws InvalidCipherTextException

      Adds the contents of two encrypted blocks mod sigma
      Parameters:
        `block1` - the first encrypted block
        `block2` - the second encrypted block
      Returns:
        encrypt((block1 + block2) mod sigma)
      Throws:
        `InvalidCipherTextException`

    - #### processData

          public byte[] processData(byte[] data)
                             throws InvalidCipherTextException

      Convenience Method for data exchange with the cipher. Determines blocksize and splits data to blocksize.
      Parameters:
        `data` - the data to be processed
      Returns:
        the data after it went through the NaccacheSternEngine.
      Throws:
        `InvalidCipherTextException`