Package ptolemy.actor.lib.security

Class SymmetricEncryption

  • All Implemented Interfaces:
    java.lang.Cloneable, Actor, Executable, FiringsRecordable, Initializable, TypedActor, Changeable, Debuggable, DebugListener, Derivable, Instantiable, ModelErrorHandler, MoMLExportable, Moveable, Nameable
    public class SymmetricEncryption
extends CipherActor
    Encrypt an unsigned byte array using a symmetric algorithm.

    In cryptography, a symmetric algorithm is an algorithm that uses the same key for encryption and decryption. An asymmetric algorithm uses two different keys: a public key and a private key. Sun's documentation says that asymmetric algorithms are usually much slower than symmetric algorithms. The initial default set of algorithms that comes with the Sun JDK does not include an asymmetric encryption algorithm, though other algorithms may be installed by the system administrator.

    This actor reads an unsigned byte array at the input port, encrypts the data using the data from the key port and then writes the unsigned byte array results to the output port.

    The key should be the same for both the SymmetricDecryption actor and this actor. The key should not be visible to users as the security of the encrypted message relies on the secrecy of this key.

    The algorithm parameter determines which algorithm is used. The algorithm specified must be symmetric. The mode and padding can also be specified in the mode and padding parameters. In case a provider specific instance of an algorithm is needed the provider may also be specified in the provider parameter.

    Note that for simplicity, this actor does not support the notion of algorithm parameters, so the algorithm must not require that algorithm parameters be transmitted separately from the key. If the user selects an algorithm that uses algorithm parameters, then an exception will likely be thrown.

    This actor relies on the Java Cryptography Architecture (JCA) and Java Cryptography Extension (JCE). See the CryptographyActor documentation for resources about the JCE.

    Since:
    Ptolemy II 4.0
    Version:
    $Id$
    Author:
    Christopher Hylands Brooks, Contributor: Rakesh Reddy
    Pt.AcceptedRating:
    Yellow (cxh)
    Pt.ProposedRating:
    Green (cxh)

    • Field Detail

      • key

        public TypedIOPort key
        The key to be used by this actor to encrypt the data. The type is an KeyToken containing a java.security.Key. Usually the output of the SecretKey actor is connected to this port

    • Method Detail

      • fire

        public void fire()
          throws IllegalActionException
        If there is a token on the input port, this method takes the data from the input and encrypts the data based on the algorithm, provider, mode and padding using the key read in from the key port. This processed data is then sent on the output port. All parameters should be the same as the corresponding decryption actor. This method calls javax.crypto.Cipher.init() with the value of the key.
        Specified by:
        fire in interface Executable
        Overrides:
        fire in class CipherActor
        Throws:
        IllegalActionException - If thrown by base class.

      • _process

        protected byte[] _process​(byte[] dataBytes)
                   throws IllegalActionException
        Encrypt the data using the javax.crypto.Cipher.
        Specified by:
        _process in class CryptographyActor
        Parameters:
        dataBytes - the data to be encrypted.
        Returns:
        byte[] the encrypted data.
        Throws:
        IllegalActionException - If error occurs in ByteArrayOutputStream, if the key is invalid, if the padding is bad or if the block size is illegal.