docs/components/modules/ROOT/pages/crypto-dataformat.adoc - camel - Git at Google

 [[crypto-dataformat]]
 = Crypto (Java Cryptographic Extension) DataFormat
 :page-source: components/camel-crypto/src/main/docs/crypto-dataformat.adoc

 *Available as of Camel version 2.3*

 The Crypto Data Format integrates the Java
 Cryptographic Extension into Camel, allowing simple and flexible
 encryption and decryption of messages using Camel's familiar marshall
 and unmarshal formatting mechanism. It assumes marshalling to mean
 encryption to cyphertext and unmarshalling to mean decryption back to
 the original plaintext. This data format implements only symmetric
 (shared-key) encryption and decyption.

 == CryptoDataFormat Options

 // dataformat options: START
 The Crypto (Java Cryptographic Extension) dataformat supports 10 options, which are listed below.


 [width="100%",cols="2s,1m,1m,6",options="header"]
 |===
 | Name | Default | Java Type | Description
 | algorithm | DES/CBC/PKCS5Padding | String | The JCE algorithm name indicating the cryptographic algorithm that will be used. Is by default DES/CBC/PKCS5Padding.
 | cryptoProvider |  | String | The name of the JCE Security Provider that should be used.
 | keyRef |  | String | Refers to the secret key to lookup from the register to use.
 | initVectorRef |  | String | Refers to a byte array containing the Initialization Vector that will be used to initialize the Cipher.
 | algorithmParameterRef |  | String | A JCE AlgorithmParameterSpec used to initialize the Cipher. Will lookup the type using the given name as a java.security.spec.AlgorithmParameterSpec type.
 | buffersize |  | Integer | The size of the buffer used in the signature process.
 | macAlgorithm | HmacSHA1 | String | The JCE algorithm name indicating the Message Authentication algorithm.
 | shouldAppendHMAC | false | Boolean | Flag indicating that a Message Authentication Code should be calculated and appended to the encrypted data.
 | inline | false | Boolean | Flag indicating that the configured IV should be inlined into the encrypted data stream. Is by default false.
 | contentTypeHeader | false | Boolean | Whether the data format should set the Content-Type header with the type from the data format if the data format is capable of doing so. For example application/xml for data formats marshalling to XML, or application/json for data formats marshalling to JSon etc.
 |===
 // dataformat options: END
 // spring-boot-auto-configure options: START
 == Spring Boot Auto-Configuration

 When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

 [source,xml]
 ----
 <dependency>
   <groupId>org.apache.camel</groupId>
   <artifactId>camel-crypto-starter</artifactId>
   <version>x.x.x</version>
   <!-- use the same version as your Camel core version -->
 </dependency>
 ----


 The component supports 33 options, which are listed below.


 [width="100%",cols="2,5,^1,2",options="header"]
 |===
 | Name | Description | Default | Type
 | *camel.component.crypto.basic-property-binding* | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | Boolean
 | *camel.component.crypto.configuration.algorithm* | Sets the JCE name of the Algorithm that should be used for the signer. | SHA1WithDSA | String
 | *camel.component.crypto.configuration.alias* | Sets the alias used to query the KeyStore for keys and {@link java.security.cert.Certificate Certificates} to be used in signing and verifying exchanges. This value can be provided at runtime via the message header {@link org.apache.camel.component.crypto.DigitalSignatureConstants#KEYSTORE_ALIAS} |  | String
 | *camel.component.crypto.configuration.buffer-size* | Set the size of the buffer used to read in the Exchange payload data. | 2048 | Integer
 | *camel.component.crypto.configuration.certificate* | Set the Certificate that should be used to verify the signature in the exchange based on its payload. |  | Certificate
 | *camel.component.crypto.configuration.certificate-name* | Sets the reference name for a PrivateKey that can be found in the registry. |  | String
 | *camel.component.crypto.configuration.clear-headers* | Determines if the Signature specific headers be cleared after signing and verification. Defaults to true, and should only be made otherwise at your extreme peril as vital private information such as Keys and passwords may escape if unset. | true | Boolean
 | *camel.component.crypto.configuration.crypto-operation* | Set the Crypto operation from that supplied after the crypto scheme in the endpoint uri e.g. crypto:sign sets sign as the operation. |  | CryptoOperation
 | *camel.component.crypto.configuration.key-store-parameters* | Sets the KeyStore that can contain keys and Certficates for use in signing and verifying exchanges based on the given KeyStoreParameters. A {@link KeyStore} is typically used with an alias, either one supplied in the Route definition or dynamically via the message header "CamelSignatureKeyStoreAlias". If no alias is supplied and there is only a single entry in the Keystore, then this single entry will be used. |  | KeyStoreParameters
 | *camel.component.crypto.configuration.keystore* | Sets the KeyStore that can contain keys and Certficates for use in signing and verifying exchanges. A {@link KeyStore} is typically used with an alias, either one supplied in the Route definition or dynamically via the message header "CamelSignatureKeyStoreAlias". If no alias is supplied and there is only a single entry in the Keystore, then this single entry will be used. |  | KeyStore
 | *camel.component.crypto.configuration.keystore-name* | Sets the reference name for a Keystore that can be found in the registry. |  | String
 | *camel.component.crypto.configuration.name* | The logical name of this operation. |  | String
 | *camel.component.crypto.configuration.password* | Sets the password used to access an aliased {@link PrivateKey} in the KeyStore. |  | String
 | *camel.component.crypto.configuration.private-key* | Set the PrivateKey that should be used to sign the exchange |  | PrivateKey
 | *camel.component.crypto.configuration.private-key-name* | Sets the reference name for a PrivateKey that can be found in the registry. |  | String
 | *camel.component.crypto.configuration.provider* | Set the id of the security provider that provides the configured {@link Signature} algorithm. |  | String
 | *camel.component.crypto.configuration.public-key* | Set the PublicKey that should be used to verify the signature in the exchange. |  | PublicKey
 | *camel.component.crypto.configuration.public-key-name* | Sets the reference name for a publicKey that can be found in the registry. |  | String
 | *camel.component.crypto.configuration.secure-random* | Set the SecureRandom used to initialize the Signature service |  | SecureRandom
 | *camel.component.crypto.configuration.secure-random-name* | Sets the reference name for a SecureRandom that can be found in the registry. |  | String
 | *camel.component.crypto.configuration.signature-header-name* | Set the name of the message header that should be used to store the base64 encoded signature. This defaults to 'CamelDigitalSignature' |  | String
 | *camel.component.crypto.enabled* | Enable crypto component | true | Boolean
 | *camel.dataformat.crypto.algorithm* | The JCE algorithm name indicating the cryptographic algorithm that will be used. Is by default DES/CBC/PKCS5Padding. | DES/CBC/PKCS5Padding | String
 | *camel.dataformat.crypto.algorithm-parameter-ref* | A JCE AlgorithmParameterSpec used to initialize the Cipher. Will lookup the type using the given name as a java.security.spec.AlgorithmParameterSpec type. |  | String
 | *camel.dataformat.crypto.buffersize* | The size of the buffer used in the signature process. |  | Integer
 | *camel.dataformat.crypto.content-type-header* | Whether the data format should set the Content-Type header with the type from the data format if the data format is capable of doing so. For example application/xml for data formats marshalling to XML, or application/json for data formats marshalling to JSon etc. | false | Boolean
 | *camel.dataformat.crypto.crypto-provider* | The name of the JCE Security Provider that should be used. |  | String
 | *camel.dataformat.crypto.enabled* | Enable crypto dataformat | true | Boolean
 | *camel.dataformat.crypto.init-vector-ref* | Refers to a byte array containing the Initialization Vector that will be used to initialize the Cipher. |  | String
 | *camel.dataformat.crypto.inline* | Flag indicating that the configured IV should be inlined into the encrypted data stream. Is by default false. | false | Boolean
 | *camel.dataformat.crypto.key-ref* | Refers to the secret key to lookup from the register to use. |  | String
 | *camel.dataformat.crypto.mac-algorithm* | The JCE algorithm name indicating the Message Authentication algorithm. | HmacSHA1 | String
 | *camel.dataformat.crypto.should-append-h-m-a-c* | Flag indicating that a Message Authentication Code should be calculated and appended to the encrypted data. | false | Boolean
 |===
 // spring-boot-auto-configure options: END
 ND


 == Basic Usage

 At its most basic all that is required to encrypt/decrypt an exchange is a shared secret key.
 If one or more instances of the Crypto data format are configured with this key the format can
 be used to encrypt the payload in one route (or part of one) and decrypted in another.
 For example, using the Java DSL as follows:

 [source,java]
 ----------------------------------------------------------
 KeyGenerator generator = KeyGenerator.getInstance("DES");

 CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", generator.generateKey());

 from("direct:basic-encryption")
     .marshal(cryptoFormat)
     .to("mock:encrypted")
     .unmarshal(cryptoFormat)
     .to("mock:unencrypted");
 ----------------------------------------------------------


 In Spring the dataformat is configured first and then used in routes

 [source,xml]
 ----------------------------------------------------------
 <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
   <dataFormats>
     <crypto id="basic" algorithm="DES" keyRef="desKey" />
   </dataFormats>
     ...
   <route>
     <from uri="direct:basic-encryption" />
     <marshal ref="basic" />
     <to uri="mock:encrypted" />
     <unmarshal ref="basic" />
     <to uri="mock:unencrypted" />
   </route>
 </camelContext>
 ----------------------------------------------------------


 == Specifying the Encryption Algorithm

 Changing the algorithm is a matter of supplying the JCE algorithm name. If you change the algorithm you will need to use a compatible key.

 [source,java]
 ----------------------------------------------------------
 KeyGenerator generator = KeyGenerator.getInstance("DES");

 CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", generator.generateKey());
 cryptoFormat.setShouldAppendHMAC(true);
 cryptoFormat.setMacAlgorithm("HmacMD5");

 from("direct:hmac-algorithm")
     .marshal(cryptoFormat)
     .to("mock:encrypted")
     .unmarshal(cryptoFormat)
     .to("mock:unencrypted");
 ----------------------------------------------------------

 A list of the available algorithms in Java 7 is available via the Java Cryptography Architecture Standard Algorithm Name Documentation.


 == Specifying an Initialization Vector

 Some crypto algorithms, particularly block algorithms, require configuration with an initial block of data known as an Initialization Vector.
 In the JCE this is passed as an AlgorithmParameterSpec when the Cipher is initialized.
 To use such a vector with the CryptoDataFormat you can configure it with a byte[] containing the required data e.g.

 [source,java]
 ----------------------------------------------------------
 KeyGenerator generator = KeyGenerator.getInstance("DES");
 byte[] initializationVector = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};

 CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES/CBC/PKCS5Padding", generator.generateKey());
 cryptoFormat.setInitializationVector(initializationVector);

 from("direct:init-vector")
     .marshal(cryptoFormat)
     .to("mock:encrypted")
     .unmarshal(cryptoFormat)
     .to("mock:unencrypted");
 ----------------------------------------------------------

 or with spring, suppling a reference to a byte[]

 [source,xml]
 ----------------------------------------------------------
 <crypto id="initvector" algorithm="DES/CBC/PKCS5Padding" keyRef="desKey" initVectorRef="initializationVector" />
 ----------------------------------------------------------

 The same vector is required in both the encryption and decryption phases. As it is not necessary to keep the IV a secret,
 the DataFormat allows for it to be inlined into the encrypted data and subsequently read out in the decryption
 phase to initialize the Cipher. To inline the IV set the /oinline flag.


 [source,java]
 ----------------------------------------------------------
 KeyGenerator generator = KeyGenerator.getInstance("DES");
 byte[] initializationVector = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
 SecretKey key = generator.generateKey();

 CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES/CBC/PKCS5Padding", key);
 cryptoFormat.setInitializationVector(initializationVector);
 cryptoFormat.setShouldInlineInitializationVector(true);
 CryptoDataFormat decryptFormat = new CryptoDataFormat("DES/CBC/PKCS5Padding", key);
 decryptFormat.setShouldInlineInitializationVector(true);

 from("direct:inline")
     .marshal(cryptoFormat)
     .to("mock:encrypted")
     .unmarshal(decryptFormat)
     .to("mock:unencrypted");
 ----------------------------------------------------------

 or with spring.

 [source,xml]
 ----------------------------------------------------------
 <crypto id="inline" algorithm="DES/CBC/PKCS5Padding" keyRef="desKey" initVectorRef="initializationVector"
   inline="true" />
 <crypto id="inline-decrypt" algorithm="DES/CBC/PKCS5Padding" keyRef="desKey" inline="true" />
 ----------------------------------------------------------

 For more information of the use of Initialization Vectors, consult

 * http://en.wikipedia.org/wiki/Initialization_vector
 * http://www.herongyang.com/Cryptography/
 * http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation


 == Hashed Message Authentication Codes (HMAC)
 To avoid attacks against the encrypted data while it is in transit the CryptoDataFormat can also calculate a Message Authentication
 Code for the encrypted exchange contents based on a configurable MAC algorithm. The calculated HMAC is appended to the stream after encryption.
 It is separated from the stream in the decryption phase. The MAC is recalculated and verified against the transmitted version to insure nothing
 was tampered with in transit.For more information on Message Authentication Codes see http://en.wikipedia.org/wiki/HMAC

 [source,java]
 ----------------------------------------------------------
 KeyGenerator generator = KeyGenerator.getInstance("DES");

 CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", generator.generateKey());
 cryptoFormat.setShouldAppendHMAC(true);

 from("direct:hmac")
     .marshal(cryptoFormat)
     .to("mock:encrypted")
     .unmarshal(cryptoFormat)
     .to("mock:unencrypted");
 ----------------------------------------------------------

 or with spring.

 [source,xml]
 ----------------------------------------------------------
 <crypto id="hmac" algorithm="DES" keyRef="desKey" shouldAppendHMAC="true" />
 ----------------------------------------------------------

 By default the HMAC is calculated using the HmacSHA1 mac algorithm though this can be easily changed by supplying a different algorithm name.
 See here for how to check what algorithms are available through the configured security providers

 [source,java]
 ----------------------------------------------------------
 KeyGenerator generator = KeyGenerator.getInstance("DES");

 CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", generator.generateKey());
 cryptoFormat.setShouldAppendHMAC(true);
 cryptoFormat.setMacAlgorithm("HmacMD5");

 from("direct:hmac-algorithm")
     .marshal(cryptoFormat)
     .to("mock:encrypted")
     .unmarshal(cryptoFormat)
     .to("mock:unencrypted");
 ----------------------------------------------------------

 or with spring.

 [source,xml]
 ----------------------------------------------------------
 <crypto id="hmac-algorithm" algorithm="DES" keyRef="desKey" macAlgorithm="HmacMD5" shouldAppendHMAC="true" />
 ----------------------------------------------------------


 == Supplying Keys Dynamically

 When using a Recipient list or similar EIP the recipient of an exchange can vary dynamically.
 Using the same key across all recipients may neither be feasible or desirable. It would be useful to be able to specify
 keys dynamically on a per exchange basis. The exchange could then be dynamically enriched with the key of its target
 recipient before being processed by the data format. To facilitate this the DataFormat allow for keys to be supplied
 dynamically via the message headers below

 * CryptoDataFormat.KEY "CamelCryptoKey"

 [source,java]
 ----------------------------------------------------------
 CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", null);
 /**
  * Note: the header containing the key should be cleared after
  * marshalling to stop it from leaking by accident and
  * potentially being compromised. The processor version below is
  * arguably better as the key is left in the header when you use
  * the DSL leaks the fact that camel encryption was used.
  */
 from("direct:key-in-header-encrypt")
     .marshal(cryptoFormat)
     .removeHeader(CryptoDataFormat.KEY)
     .to("mock:encrypted");

 from("direct:key-in-header-decrypt").unmarshal(cryptoFormat).process(new Processor() {
     public void process(Exchange exchange) throws Exception {
         exchange.getIn().getHeaders().remove(CryptoDataFormat.KEY);
         exchange.getOut().copyFrom(exchange.getIn());
     }
 }).to("mock:unencrypted");
 ----------------------------------------------------------

 or with spring.

 [source,xml]
 ----------------------------------------------------------
 <crypto id="nokey" algorithm="DES" />
 ----------------------------------------------------------


 == Dependencies

 To use the xref:crypto-component.adoc[Crypto] dataformat in your camel routes you
 need to add the following dependency to your pom.

 [source,xml]
 ----------------------------------------------------------
 <dependency>
   <groupId>org.apache.camel</groupId>
   <artifactId>camel-crypto</artifactId>
   <version>x.x.x</version>
   <!-- use the same version as your Camel core version -->
 </dependency>
 ----------------------------------------------------------
	[[crypto-dataformat]]
	= Crypto (Java Cryptographic Extension) DataFormat
	:page-source: components/camel-crypto/src/main/docs/crypto-dataformat.adoc

	Available as of Camel version 2.3

	The Crypto Data Format integrates the Java
	Cryptographic Extension into Camel, allowing simple and flexible
	encryption and decryption of messages using Camel's familiar marshall
	and unmarshal formatting mechanism. It assumes marshalling to mean
	encryption to cyphertext and unmarshalling to mean decryption back to
	the original plaintext. This data format implements only symmetric
	(shared-key) encryption and decyption.

	== CryptoDataFormat Options

	// dataformat options: START
	The Crypto (Java Cryptographic Extension) dataformat supports 10 options, which are listed below.



	[width="100%",cols="2s,1m,1m,6",options="header"]
	\|===
	\| Name \| Default \| Java Type \| Description
	\| algorithm \| DES/CBC/PKCS5Padding \| String \| The JCE algorithm name indicating the cryptographic algorithm that will be used. Is by default DES/CBC/PKCS5Padding.
	\| cryptoProvider \| \| String \| The name of the JCE Security Provider that should be used.
	\| keyRef \| \| String \| Refers to the secret key to lookup from the register to use.
	\| initVectorRef \| \| String \| Refers to a byte array containing the Initialization Vector that will be used to initialize the Cipher.
	\| algorithmParameterRef \| \| String \| A JCE AlgorithmParameterSpec used to initialize the Cipher. Will lookup the type using the given name as a java.security.spec.AlgorithmParameterSpec type.
	\| buffersize \| \| Integer \| The size of the buffer used in the signature process.
	\| macAlgorithm \| HmacSHA1 \| String \| The JCE algorithm name indicating the Message Authentication algorithm.
	\| shouldAppendHMAC \| false \| Boolean \| Flag indicating that a Message Authentication Code should be calculated and appended to the encrypted data.
	\| inline \| false \| Boolean \| Flag indicating that the configured IV should be inlined into the encrypted data stream. Is by default false.
	\| contentTypeHeader \| false \| Boolean \| Whether the data format should set the Content-Type header with the type from the data format if the data format is capable of doing so. For example application/xml for data formats marshalling to XML, or application/json for data formats marshalling to JSon etc.
	\|===
	// dataformat options: END
	// spring-boot-auto-configure options: START
	== Spring Boot Auto-Configuration

	When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

	[source,xml]
	----
	<dependency>
	<groupId>org.apache.camel</groupId>
	<artifactId>camel-crypto-starter</artifactId>
	<version>x.x.x</version>
	<!-- use the same version as your Camel core version -->
	</dependency>
	----


	The component supports 33 options, which are listed below.



	[width="100%",cols="2,5,^1,2",options="header"]
	\|===
	\| Name \| Description \| Default \| Type
	\| camel.component.crypto.basic-property-binding \| Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities \| false \| Boolean
	\| camel.component.crypto.configuration.algorithm \| Sets the JCE name of the Algorithm that should be used for the signer. \| SHA1WithDSA \| String
	\| camel.component.crypto.configuration.alias \| Sets the alias used to query the KeyStore for keys and {@link java.security.cert.Certificate Certificates} to be used in signing and verifying exchanges. This value can be provided at runtime via the message header {@link org.apache.camel.component.crypto.DigitalSignatureConstants#KEYSTORE_ALIAS} \| \| String
	\| camel.component.crypto.configuration.buffer-size \| Set the size of the buffer used to read in the Exchange payload data. \| 2048 \| Integer
	\| camel.component.crypto.configuration.certificate \| Set the Certificate that should be used to verify the signature in the exchange based on its payload. \| \| Certificate
	\| camel.component.crypto.configuration.certificate-name \| Sets the reference name for a PrivateKey that can be found in the registry. \| \| String
	\| camel.component.crypto.configuration.clear-headers \| Determines if the Signature specific headers be cleared after signing and verification. Defaults to true, and should only be made otherwise at your extreme peril as vital private information such as Keys and passwords may escape if unset. \| true \| Boolean
	\| camel.component.crypto.configuration.crypto-operation \| Set the Crypto operation from that supplied after the crypto scheme in the endpoint uri e.g. crypto:sign sets sign as the operation. \| \| CryptoOperation
	\| camel.component.crypto.configuration.key-store-parameters \| Sets the KeyStore that can contain keys and Certficates for use in signing and verifying exchanges based on the given KeyStoreParameters. A {@link KeyStore} is typically used with an alias, either one supplied in the Route definition or dynamically via the message header "CamelSignatureKeyStoreAlias". If no alias is supplied and there is only a single entry in the Keystore, then this single entry will be used. \| \| KeyStoreParameters
	\| camel.component.crypto.configuration.keystore \| Sets the KeyStore that can contain keys and Certficates for use in signing and verifying exchanges. A {@link KeyStore} is typically used with an alias, either one supplied in the Route definition or dynamically via the message header "CamelSignatureKeyStoreAlias". If no alias is supplied and there is only a single entry in the Keystore, then this single entry will be used. \| \| KeyStore
	\| camel.component.crypto.configuration.keystore-name \| Sets the reference name for a Keystore that can be found in the registry. \| \| String
	\| camel.component.crypto.configuration.name \| The logical name of this operation. \| \| String
	\| camel.component.crypto.configuration.password \| Sets the password used to access an aliased {@link PrivateKey} in the KeyStore. \| \| String
	\| camel.component.crypto.configuration.private-key \| Set the PrivateKey that should be used to sign the exchange \| \| PrivateKey
	\| camel.component.crypto.configuration.private-key-name \| Sets the reference name for a PrivateKey that can be found in the registry. \| \| String
	\| camel.component.crypto.configuration.provider \| Set the id of the security provider that provides the configured {@link Signature} algorithm. \| \| String
	\| camel.component.crypto.configuration.public-key \| Set the PublicKey that should be used to verify the signature in the exchange. \| \| PublicKey
	\| camel.component.crypto.configuration.public-key-name \| Sets the reference name for a publicKey that can be found in the registry. \| \| String
	\| camel.component.crypto.configuration.secure-random \| Set the SecureRandom used to initialize the Signature service \| \| SecureRandom
	\| camel.component.crypto.configuration.secure-random-name \| Sets the reference name for a SecureRandom that can be found in the registry. \| \| String
	\| camel.component.crypto.configuration.signature-header-name \| Set the name of the message header that should be used to store the base64 encoded signature. This defaults to 'CamelDigitalSignature' \| \| String
	\| camel.component.crypto.enabled \| Enable crypto component \| true \| Boolean
	\| camel.dataformat.crypto.algorithm \| The JCE algorithm name indicating the cryptographic algorithm that will be used. Is by default DES/CBC/PKCS5Padding. \| DES/CBC/PKCS5Padding \| String
	\| camel.dataformat.crypto.algorithm-parameter-ref \| A JCE AlgorithmParameterSpec used to initialize the Cipher. Will lookup the type using the given name as a java.security.spec.AlgorithmParameterSpec type. \| \| String
	\| camel.dataformat.crypto.buffersize \| The size of the buffer used in the signature process. \| \| Integer
	\| camel.dataformat.crypto.content-type-header \| Whether the data format should set the Content-Type header with the type from the data format if the data format is capable of doing so. For example application/xml for data formats marshalling to XML, or application/json for data formats marshalling to JSon etc. \| false \| Boolean
	\| camel.dataformat.crypto.crypto-provider \| The name of the JCE Security Provider that should be used. \| \| String
	\| camel.dataformat.crypto.enabled \| Enable crypto dataformat \| true \| Boolean
	\| camel.dataformat.crypto.init-vector-ref \| Refers to a byte array containing the Initialization Vector that will be used to initialize the Cipher. \| \| String
	\| camel.dataformat.crypto.inline \| Flag indicating that the configured IV should be inlined into the encrypted data stream. Is by default false. \| false \| Boolean
	\| camel.dataformat.crypto.key-ref \| Refers to the secret key to lookup from the register to use. \| \| String
	\| camel.dataformat.crypto.mac-algorithm \| The JCE algorithm name indicating the Message Authentication algorithm. \| HmacSHA1 \| String
	\| camel.dataformat.crypto.should-append-h-m-a-c \| Flag indicating that a Message Authentication Code should be calculated and appended to the encrypted data. \| false \| Boolean
	\|===
	// spring-boot-auto-configure options: END
	ND


	== Basic Usage

	At its most basic all that is required to encrypt/decrypt an exchange is a shared secret key.
	If one or more instances of the Crypto data format are configured with this key the format can
	be used to encrypt the payload in one route (or part of one) and decrypted in another.
	For example, using the Java DSL as follows:

	[source,java]
	----------------------------------------------------------
	KeyGenerator generator = KeyGenerator.getInstance("DES");

	CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", generator.generateKey());

	from("direct:basic-encryption")
	.marshal(cryptoFormat)
	.to("mock:encrypted")
	.unmarshal(cryptoFormat)
	.to("mock:unencrypted");
	----------------------------------------------------------


	In Spring the dataformat is configured first and then used in routes

	[source,xml]
	----------------------------------------------------------
	<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
	<dataFormats>
	<crypto id="basic" algorithm="DES" keyRef="desKey" />
	</dataFormats>
	...
	<route>
	<from uri="direct:basic-encryption" />
	<marshal ref="basic" />
	<to uri="mock:encrypted" />
	<unmarshal ref="basic" />
	<to uri="mock:unencrypted" />
	</route>
	</camelContext>
	----------------------------------------------------------


	== Specifying the Encryption Algorithm

	Changing the algorithm is a matter of supplying the JCE algorithm name. If you change the algorithm you will need to use a compatible key.

	[source,java]
	----------------------------------------------------------
	KeyGenerator generator = KeyGenerator.getInstance("DES");

	CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", generator.generateKey());
	cryptoFormat.setShouldAppendHMAC(true);
	cryptoFormat.setMacAlgorithm("HmacMD5");

	from("direct:hmac-algorithm")
	.marshal(cryptoFormat)
	.to("mock:encrypted")
	.unmarshal(cryptoFormat)
	.to("mock:unencrypted");
	----------------------------------------------------------

	A list of the available algorithms in Java 7 is available via the Java Cryptography Architecture Standard Algorithm Name Documentation.


	== Specifying an Initialization Vector

	Some crypto algorithms, particularly block algorithms, require configuration with an initial block of data known as an Initialization Vector.
	In the JCE this is passed as an AlgorithmParameterSpec when the Cipher is initialized.
	To use such a vector with the CryptoDataFormat you can configure it with a byte[] containing the required data e.g.

	[source,java]
	----------------------------------------------------------
	KeyGenerator generator = KeyGenerator.getInstance("DES");
	byte[] initializationVector = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};

	CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES/CBC/PKCS5Padding", generator.generateKey());
	cryptoFormat.setInitializationVector(initializationVector);

	from("direct:init-vector")
	.marshal(cryptoFormat)
	.to("mock:encrypted")
	.unmarshal(cryptoFormat)
	.to("mock:unencrypted");
	----------------------------------------------------------

	or with spring, suppling a reference to a byte[]

	[source,xml]
	----------------------------------------------------------
	<crypto id="initvector" algorithm="DES/CBC/PKCS5Padding" keyRef="desKey" initVectorRef="initializationVector" />
	----------------------------------------------------------

	The same vector is required in both the encryption and decryption phases. As it is not necessary to keep the IV a secret,
	the DataFormat allows for it to be inlined into the encrypted data and subsequently read out in the decryption
	phase to initialize the Cipher. To inline the IV set the /oinline flag.


	[source,java]
	----------------------------------------------------------
	KeyGenerator generator = KeyGenerator.getInstance("DES");
	byte[] initializationVector = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
	SecretKey key = generator.generateKey();

	CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES/CBC/PKCS5Padding", key);
	cryptoFormat.setInitializationVector(initializationVector);
	cryptoFormat.setShouldInlineInitializationVector(true);
	CryptoDataFormat decryptFormat = new CryptoDataFormat("DES/CBC/PKCS5Padding", key);
	decryptFormat.setShouldInlineInitializationVector(true);

	from("direct:inline")
	.marshal(cryptoFormat)
	.to("mock:encrypted")
	.unmarshal(decryptFormat)
	.to("mock:unencrypted");
	----------------------------------------------------------

	or with spring.

	[source,xml]
	----------------------------------------------------------
	<crypto id="inline" algorithm="DES/CBC/PKCS5Padding" keyRef="desKey" initVectorRef="initializationVector"
	inline="true" />
	<crypto id="inline-decrypt" algorithm="DES/CBC/PKCS5Padding" keyRef="desKey" inline="true" />
	----------------------------------------------------------

	For more information of the use of Initialization Vectors, consult

	* http://en.wikipedia.org/wiki/Initialization_vector
	* http://www.herongyang.com/Cryptography/
	* http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation


	== Hashed Message Authentication Codes (HMAC)
	To avoid attacks against the encrypted data while it is in transit the CryptoDataFormat can also calculate a Message Authentication
	Code for the encrypted exchange contents based on a configurable MAC algorithm. The calculated HMAC is appended to the stream after encryption.
	It is separated from the stream in the decryption phase. The MAC is recalculated and verified against the transmitted version to insure nothing
	was tampered with in transit.For more information on Message Authentication Codes see http://en.wikipedia.org/wiki/HMAC

	[source,java]
	----------------------------------------------------------
	KeyGenerator generator = KeyGenerator.getInstance("DES");

	CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", generator.generateKey());
	cryptoFormat.setShouldAppendHMAC(true);

	from("direct:hmac")
	.marshal(cryptoFormat)
	.to("mock:encrypted")
	.unmarshal(cryptoFormat)
	.to("mock:unencrypted");
	----------------------------------------------------------

	or with spring.

	[source,xml]
	----------------------------------------------------------
	<crypto id="hmac" algorithm="DES" keyRef="desKey" shouldAppendHMAC="true" />
	----------------------------------------------------------

	By default the HMAC is calculated using the HmacSHA1 mac algorithm though this can be easily changed by supplying a different algorithm name.
	See here for how to check what algorithms are available through the configured security providers

	[source,java]
	----------------------------------------------------------
	KeyGenerator generator = KeyGenerator.getInstance("DES");

	CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", generator.generateKey());
	cryptoFormat.setShouldAppendHMAC(true);
	cryptoFormat.setMacAlgorithm("HmacMD5");

	from("direct:hmac-algorithm")
	.marshal(cryptoFormat)
	.to("mock:encrypted")
	.unmarshal(cryptoFormat)
	.to("mock:unencrypted");
	----------------------------------------------------------

	or with spring.

	[source,xml]
	----------------------------------------------------------
	<crypto id="hmac-algorithm" algorithm="DES" keyRef="desKey" macAlgorithm="HmacMD5" shouldAppendHMAC="true" />
	----------------------------------------------------------


	== Supplying Keys Dynamically

	When using a Recipient list or similar EIP the recipient of an exchange can vary dynamically.
	Using the same key across all recipients may neither be feasible or desirable. It would be useful to be able to specify
	keys dynamically on a per exchange basis. The exchange could then be dynamically enriched with the key of its target
	recipient before being processed by the data format. To facilitate this the DataFormat allow for keys to be supplied
	dynamically via the message headers below

	* CryptoDataFormat.KEY "CamelCryptoKey"

	[source,java]
	----------------------------------------------------------
	CryptoDataFormat cryptoFormat = new CryptoDataFormat("DES", null);
	/**
	* Note: the header containing the key should be cleared after
	* marshalling to stop it from leaking by accident and
	* potentially being compromised. The processor version below is
	* arguably better as the key is left in the header when you use
	* the DSL leaks the fact that camel encryption was used.
	*/
	from("direct:key-in-header-encrypt")
	.marshal(cryptoFormat)
	.removeHeader(CryptoDataFormat.KEY)
	.to("mock:encrypted");

	from("direct:key-in-header-decrypt").unmarshal(cryptoFormat).process(new Processor() {
	public void process(Exchange exchange) throws Exception {
	exchange.getIn().getHeaders().remove(CryptoDataFormat.KEY);
	exchange.getOut().copyFrom(exchange.getIn());
	}
	}).to("mock:unencrypted");
	----------------------------------------------------------

	or with spring.

	[source,xml]
	----------------------------------------------------------
	<crypto id="nokey" algorithm="DES" />
	----------------------------------------------------------


	== Dependencies

	To use the xref:crypto-component.adoc[Crypto] dataformat in your camel routes you
	need to add the following dependency to your pom.

	[source,xml]
	----------------------------------------------------------
	<dependency>
	<groupId>org.apache.camel</groupId>
	<artifactId>camel-crypto</artifactId>
	<version>x.x.x</version>
	<!-- use the same version as your Camel core version -->
	</dependency>
	----------------------------------------------------------