This project has retired. For details please refer to its Attic page.
Apache ODE – WS-Security in ODE

WS-Security in ODE

How to use WS-Security in ODE?

Only in 1.3.2+

ODE 1.3.2 introduces support for WS-Security: secure services can now be invoked from a process, and the process service itself might be secured. A first part will explain how to invoke a secured service, a second part how to secure the process service.

ODE has an Integration Layer based on Axis2 so using Rampart, the Axis2 security modules, goes without saying. As a result this section will only focus on Rampart integration. Rampart and WS-Security specifications won't be detailed here. Please refer to their ad-hoc documentations for further details.

Quick Rampart introduction

As any other Axis2 module, Rampart is configurable with Axis2 Service configuration files. For instance a service.xml document, using the parameter based configuration model, might be:


    <module ref="rampart" />

    <parameter name="OutflowSecurity">
        <items>Timestamp Signature</items>

    <parameter name="InflowSecurity">
        <items>Timestamp Signature</items>


Another example using WS-Security Policy based configuration model is listed below. See the full document here.


    <module ref="rampart"/>

    <wsp:Policy wsu:Id="SecConvPolicy2" xmlns:wsu="" xmlns:wsp="">
                <sp:SymmetricBinding xmlns:sp="">
                             <!-- truncated, see original document ny following the link above -->
                <sp:Wss11 xmlns:sp="">
                             <!-- truncated, see original document ny following the link above -->
                <sp:Trust10 xmlns:sp="">
                             <!-- truncated, see original document ny following the link above -->
                <sp:EncryptedParts xmlns:sp="">
                <ramp:RampartConfig xmlns:ramp="">

                        <ramp:crypto provider="">
                            <ramp:property name="">JKS</ramp:property>
                            <ramp:property name="">TestRampartPolicy/secured-services/client.jks</ramp:property>
                            <ramp:property name="">apache</ramp:property>
                        <ramp:crypto provider="">
                            <ramp:property name="">JKS</ramp:property>
                            <ramp:property name="">TestRampartPolicy/secured-services/client.jks</ramp:property>
                            <ramp:property name="">apache</ramp:property>



The important thing to notice is that these documents are plain Axis2 Service configuration files. And as explained in the ODE User Guide, a mechanism to handle these files already exists. So all we have to do is reuse this mechanism, the rest is pure Rampart configuration.

Let's take an example and see the actual required steps.

How to invoke a secure web service?

Prepare your service document

Assuming your process needs to invoke the secure service {}Sample03, the first step is to prepare a service document named ${process_bundle_dir}/Sample03.axis2 and containing your desired Rampart configuration.

The second step is to to make sure the resources needed to invoke the services are available to Rampart through ODE webapp classpath. Typical resources are:

  • password callback handler classes
  • Java keystores
  • property files containing keystore information

Add resources to ODE webapp classpath

How you add these resources to ODE classpath might vary depending on your application server, your global architecture or other criteria. So it's up to you to figure this out. However typical locations are:

  • ode/WEB-INF/classes
  • ode/WEB-INF/lib

An alternative for WS-Security Policies

If you're using the policy base configuration model, an alternative is available to you: use the endpoint property mechanism to attach the policy to the service. In that configuration, ODE will engage the Rampart module and load the policy when the service is invoked.

To do so:

  • save the Policy document (not the service document) in the file of your choice. For instance mypolicy.xml
  • create an endpoint file linking the service and the policy file. Basically with the two properties listed below. Note that if the path assigned to the "security.policy.file" property is relative it will be resolved against the process bundle directory. Of course if the path is absolute, it will be used as is.

How to secure the web service exposed by a process?

Applying security to a process service is no different from invoking a secured service. If the process service you're exposing is {}AbscenceRequest. All you have to do is prepare a service document named ${process_bundle_dir}/AbscenceRequest.axis2 and containing your Rampart configuration. Once again, it's up to you to add the required resources in ODE webapp classpath.

You can also use the property 'security.policy.file' to secure the process service.

Do I need to install Rampart myself?

No. ODE comes with the following Axis2 modules (and the jars they depend on): Rampart, Rahas and Addressing.

Useful resources

Rampart material

ODE test cases

How to run them

$ cd axis2-war
$ buildr test:Secure

Where are the processes executed by the unit tests?

The executed processes are generated by the build, so run the tests once, then look into the following directories. Process directories are prefixed with "process-".

  • axis2-war/target/test-classes/TestRampartPolicy/secured-services/
  • axis2-war/target/test-classes/TestRampartPolicy/secured-processes/
  • axis2-war/target/test-classes/TestRampartBasic/secured-services/
  • axis2-war/target/test-classes/TestRampartBasic/secured-processes/

the nitty-gritty details

The integration with Rampart described in this section is tested with a decent suite of unit tests. These unit tests are based on the Rampart samples. The related resources were imported into ODE repository.

These tests are divided into two parts: tests using the parameter base configuration model aka "basic tests" and tests using the policy base configuration model aka "policy tests".

ODE test cases reuse these test cases in two different scenarii:

  • the security configuration is applied to an "external" web service, and a ODE process invokes it.
  • the security configuration is applied to the web service exposed by a process.

These partitions lead to four resource directories:

Everything describes for TestRampartBasic applies to TestRampartPolicy. So for now on we will mention only TestRampartBasic.

For the "secured-services" scenario, the "external" web services are Axis archives deployed in an Axis2 webapp.

The corresponding unit test classes are and Each test class will start a list of processes that must succeed (as many processes as Rampart samples actually).

To avoid duplication these processes are generated by the build based on two process templates: one for the secured-services case, another for the secured-processes case.

The build generates processes into:

  • axis2-war/target/test-classes/TestRampartPolicy/secured-services/process-*
  • axis2-war/target/test-classes/TestRampartPolicy/secured-processes/process-*
  • axis2-war/target/test-classes/TestRampartBasic/secured-services/process-*
  • axis2-war/target/test-classes/TestRampartBasic/secured-processes/process-*