com.mulesoft.modules.cryptography.internal.pgp

Class PgpOperations

java.lang.Object

com.mulesoft.modules.cryptography.internal.pgp.PgpOperations

All Implemented Interfaces:

org.mule.runtime.api.lifecycle.Startable, org.mule.runtime.api.lifecycle.Stoppable

public class PgpOperations
extends Object
implements org.mule.runtime.api.lifecycle.Startable, org.mule.runtime.api.lifecycle.Stoppable

GPG operations.

Since:

1.0

Field Summary

Fields inherited from interface org.mule.runtime.api.lifecycle.Startable

PHASE_NAME

Fields inherited from interface org.mule.runtime.api.lifecycle.Stoppable

PHASE_NAME

Constructor Summary

Constructors

Constructor and Description
PgpOperations()

Method Summary

Modifier and Type	Method and Description
InputStream	pgpBinaryToArmored(InputStream content) Converts an encrypted PGP message or a PGP signature to an ASCII armored representation, suitable for plain text channels.
InputStream	pgpDecrypt(PgpConfiguration config, InputStream content, String fileName, boolean validateIfSignatureFound) Decrypt a stream using PGP, giving the original data as a result.
InputStream	pgpEncrypt(PgpConfiguration config, InputStream content, PgpEncryptionAlgorithm algorithm, String fileName, PgpKeySelection keySelection, boolean disableMDC) Encrypt a stream using PGP, giving an ASCII-armored stream output as a result.
InputStream	pgpEncryptAndSign(PgpConfiguration config, InputStream content, PgpEncryptionAlgorithm algorithm, String fileName, PgpKeySelection encryptionKeySelection, PgpKeySelection signKeySelection, boolean disableMDC) Encrypt a stream using PGP, giving an ASCII-armored stream output as a result.
InputStream	pgpEncryptBinary(PgpConfiguration config, InputStream content, PgpEncryptionAlgorithm algorithm, String fileName, PgpKeySelection keySelection, boolean disableMDC) Encrypt a stream using PGP, giving a binary output as a result.
InputStream	pgpSign(PgpConfiguration config, InputStream content, PgpSignatureAlgorithm algorithm, PgpKeySelection keySelection) Create a detached (standalone) PGP signature of the stream.
InputStream	pgpSignBinary(PgpConfiguration config, InputStream content, PgpSignatureAlgorithm algorithm, PgpKeySelection keySelection) Create a detached (standalone) PGP signature of the stream.
void	pgpValidate(PgpConfiguration config, InputStream value, InputStream expected) Validate a PGP signature against a stream, to authenticate it.
void	start()
void	stop()

Methods inherited from class java.lang.Object

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

Constructor Detail

PgpOperations

public PgpOperations()

Method Detail

pgpEncrypt

@MediaType(value="text/plain")
 @Throws(value=EncryptionErrorTypeProvider.class)
 @Execution(value=CPU_INTENSIVE)
public InputStream pgpEncrypt(@Config
                                                                                                                                                PgpConfiguration config,
                                                                                                                                                @Content
                                                                                                                                                InputStream content,
                                                                                                                                                @Optional(defaultValue="AES_256")
                                                                                                                                                PgpEncryptionAlgorithm algorithm,
                                                                                                                                                @Optional(defaultValue="stream")
                                                                                                                                                String fileName,
                                                                                                                                                @ParameterGroup(name="Key selection")
                                                                                                                                                PgpKeySelection keySelection,
                                                                                                                                                @Summary(value="If set, MDC (modification detection code) will not be used during encryption") @Optional(defaultValue="false")
                                                                                                                                                boolean disableMDC)

Encrypt a stream using PGP, giving an ASCII-armored stream output as a result. The encryption is done with the public key of the recipient, so the secret passphrase is not required.

Parameters:

config - the PGP configuration

content - the content to encrypt

algorithm - the symmetric algorithm to use for encryption

fileName - the internal file name to use in the resulting PGP header

keySelection - the key used to encrypt the message

Returns:

the encrypted version of the input, in ASCII armored form

pgpEncryptAndSign

@Summary(value="Performs an atomic encrypt and sign over a given payload. This lets an encrypted message carry a integrity check (the signature) over its contents.")
 @MediaType(value="text/plain")
 @Throws(value=EncryptionErrorTypeProvider.class)
 @Execution(value=CPU_INTENSIVE)
public InputStream pgpEncryptAndSign(@Config
                                                                                                                                                                                                                                                                                                                              PgpConfiguration config,
                                                                                                                                                                                                                                                                                                                              @Content
                                                                                                                                                                                                                                                                                                                              InputStream content,
                                                                                                                                                                                                                                                                                                                              @Optional(defaultValue="AES_256")
                                                                                                                                                                                                                                                                                                                              PgpEncryptionAlgorithm algorithm,
                                                                                                                                                                                                                                                                                                                              @Optional(defaultValue="stream")
                                                                                                                                                                                                                                                                                                                              String fileName,
                                                                                                                                                                                                                                                                                                                              @Summary(value="The recipients public key that will be used to encrypt the message")
                                                                                                                                                                                                                                                                                                                              PgpKeySelection encryptionKeySelection,
                                                                                                                                                                                                                                                                                                                              @Summary(value="The senders private key that will be used to sign the message")
                                                                                                                                                                                                                                                                                                                              PgpKeySelection signKeySelection,
                                                                                                                                                                                                                                                                                                                              @Summary(value="If set, MDC (modification detection code) will not be used during encryption") @Optional(defaultValue="false")
                                                                                                                                                                                                                                                                                                                              boolean disableMDC)

Encrypt a stream using PGP, giving an ASCII-armored stream output as a result. The encryption is done with the public key of the recipient, so the secret passphrase is not required.

Parameters:

config - the PGP configuration

content - the content to encrypt

algorithm - the symmetric algorithm to use for encryption

fileName - the internal file name to use in the resulting PGP header

encryptionKeySelection - the key used to encrypt the message

signKeySelection - the key used to sign the message

Returns:

the encrypted version of the input, in ASCII armored form

pgpEncryptBinary

@MediaType(value="application/octet-stream",
           strict=false)
 @Throws(value=EncryptionErrorTypeProvider.class)
 @Execution(value=CPU_INTENSIVE)
public InputStream pgpEncryptBinary(@Config
                                                                                                                                                                                             PgpConfiguration config,
                                                                                                                                                                                             @Content
                                                                                                                                                                                             InputStream content,
                                                                                                                                                                                             @Optional(defaultValue="AES_256")
                                                                                                                                                                                             PgpEncryptionAlgorithm algorithm,
                                                                                                                                                                                             @Optional(defaultValue="stream")
                                                                                                                                                                                             String fileName,
                                                                                                                                                                                             @ParameterGroup(name="Key selection")
                                                                                                                                                                                             PgpKeySelection keySelection,
                                                                                                                                                                                             @Summary(value="If set, MDC (modification detection code) will not be used during encryption") @Optional(defaultValue="false")
                                                                                                                                                                                             boolean disableMDC)

Encrypt a stream using PGP, giving a binary output as a result. The encryption is done with the public key of the recipient, so the secret passphrase is not required.

Parameters:

config - the PGP configuration

content - the content to encrypt

algorithm - the symmetric algorithm to use for encryption

fileName - the internal file name to use in the resulting PGP header

keySelection - the key used to encrypt the message

Returns:

the encrypted version of the input, in binary form

pgpDecrypt

@MediaType(value="application/octet-stream",
           strict=false)
 @Throws(value=DecryptionErrorTypeProvider.class)
 @Execution(value=CPU_INTENSIVE)
public InputStream pgpDecrypt(@Config
                                                                                                                                                                                       PgpConfiguration config,
                                                                                                                                                                                       @Content @Optional(defaultValue="#[payload]")
                                                                                                                                                                                       InputStream content,
                                                                                                                                                                                       @Optional
                                                                                                                                                                                       String fileName,
                                                                                                                                                                                       @Optional(defaultValue="false") @Summary(value="If the message being decrypted contains a signature, choose whether or not to validate the decrypted message against it")
                                                                                                                                                                                       boolean validateIfSignatureFound)

Decrypt a stream using PGP, giving the original data as a result. The decryption is done with the private key, so the secret passphrase must be provided.

Parameters:

config - the PGP configuration

content - the content to decrypt

fileName - the internal file name to decrypt, if not present the first will be used

Returns:

the original unencrypted data

pgpSign

@MediaType(value="text/plain")
 @Throws(value=SignatureErrorTypeProvider.class)
 @Execution(value=CPU_INTENSIVE)
public InputStream pgpSign(@Config
                                                                                                                                            PgpConfiguration config,
                                                                                                                                            @Content
                                                                                                                                            InputStream content,
                                                                                                                                            @Optional(defaultValue="SHA256")
                                                                                                                                            PgpSignatureAlgorithm algorithm,
                                                                                                                                            @ParameterGroup(name="Key selection")
                                                                                                                                            PgpKeySelection keySelection)

Create a detached (standalone) PGP signature of the stream. The signing is done with the private key of the sender, so the secret passphrase must be provided.

Parameters:

config - the PGP configuration

content - the content to sign

algorithm - the digest (or hashing) algorithm

keySelection - the key used to sign the data

Returns:

the ASCII armored PGP signature (does not contain the original message)

pgpSignBinary

@MediaType(value="application/octet-stream",
           strict=false)
 @Throws(value=SignatureErrorTypeProvider.class)
 @Execution(value=CPU_INTENSIVE)
public InputStream pgpSignBinary(@Config
                                                                                                                                                                                         PgpConfiguration config,
                                                                                                                                                                                         @Content
                                                                                                                                                                                         InputStream content,
                                                                                                                                                                                         @Optional(defaultValue="SHA256")
                                                                                                                                                                                         PgpSignatureAlgorithm algorithm,
                                                                                                                                                                                         @ParameterGroup(name="Key selection")
                                                                                                                                                                                         PgpKeySelection keySelection)

Create a detached (standalone) PGP signature of the stream. The signing is done with the private key of the sender, so the secret passphrase must be provided.

Parameters:

config - the PGP configuration

content - the content to sign

algorithm - the digest (or hashing) algorithm

keySelection - the key used to sign the data

Returns:

the binary PGP signature (does not contain the original message)

pgpValidate

@Validator
 @Throws(value=ValidationErrorTypeProvider.class)
 @Execution(value=CPU_INTENSIVE)
public void pgpValidate(@Config
                                                                                                                      PgpConfiguration config,
                                                                                                                      @Optional(defaultValue="#[payload]")
                                                                                                                      InputStream value,
                                                                                                                      InputStream expected)

Validate a PGP signature against a stream, to authenticate it. The validation is done with the public key of the sender, so the secret passphrase is not required.

Parameters:

config - the PGP configuration

value - the message to authenticate

expected - the signature

pgpBinaryToArmored

@MediaType(value="text/plain")
 @Throws(value=ParametersErrorTypeProvider.class)
 @Execution(value=CPU_INTENSIVE)
public InputStream pgpBinaryToArmored(@Content
                                                                                                                                                        InputStream content)

Converts an encrypted PGP message or a PGP signature to an ASCII armored representation, suitable for plain text channels.

Parameters:

content - the content to convert

Returns:

the string representation of the PGP message/signature

start

public void start()
           throws org.mule.runtime.api.exception.MuleException

Specified by:

start in interface org.mule.runtime.api.lifecycle.Startable

Throws:

org.mule.runtime.api.exception.MuleException

stop

public void stop()
          throws org.mule.runtime.api.exception.MuleException

Specified by:

stop in interface org.mule.runtime.api.lifecycle.Stoppable

Throws:

org.mule.runtime.api.exception.MuleException