http-custom-mechanism: Create a custom HTTP authorization mechanism

The http-custom-mechanism quickstart demonstrates how to implement a custom HTTP authentication mechanism that can be registered with Elytron.

What is it?

The http-custom-mechanism quickstart demonstrates how to implement a custom HTTP mechanism and then register it with Elytron. This makes it possible to override the configuration within the deployment to make use of this mechanism without requiring modifications to the deployment. This example makes use of custom HTTP headers to receive a clear text username and password and use them for authentication.

Warning

Generally you should avoid passing clear text passwords. It is only done here to simplify the example.

This example consists of the following Maven projects.

Project Description

webapp

The project in the webapp/ folder contains a deployable web application consisting of a secured servlet that is used to test the configuration. It generates the http-custom-mechanism-webapp.war archive that is used to test the secured application.

custom-module

This project contains the source for a custom HTTP authentication module that overrides the deployment configuration. It contains of the following Java classes and resources.

CustomMechanismFactory: This class implements HttpServerAuthenticationMechanismFactory and creates the new custom HttpServerAuthenticationMechanism.
CustomHeaderHttpAuthenticationMechanism: This class implements HttpServerAuthenticationMechanism and contains the source code for the custom mechanism processing. An HttpServerRequest object is passed to the evaluateRequest method. The mechanism processes the requests and uses one of the following callback methods on the request to indicate the outcome:
- authenticationComplete - The mechanism successfully authenticated the request.
- authenticationFailed - Authentication was attempted but failed.
- authenticationInProgress - Authentication started but an additional round trip is needed.
- badRequest - The authentication for this mechanism failed validation of the request.
- noAuthenticationInProgress - The mechanism did not attempt any stage of authentication.
org.wildfly.security.examples.CustomMechanismFactory: This resource file contains a single line of text that names the custom mechanism factory class, which in this case is org.jboss.as.quickstart.http_custom_mechanism.CustomMechanismFactory.

Browse the source

System Requirements

The application this project produces is designed to be run on WildFly Application Server 34 or later.

All you need to build this project is Java SE 17.0 or later, and Maven 3.6.0 or later. See Configure Maven to Build and Deploy the Quickstarts to make sure you are configured correctly for testing the quickstarts.

Use of the WILDFLY_HOME and QUICKSTART_HOME Variables

In the following instructions, replace WILDFLY_HOME with the actual path to your WildFly installation. The installation path is described in detail here: Use of WILDFLY_HOME and JBOSS_HOME Variables.

When you see the replaceable variable QUICKSTART_HOME, replace it with the path to the root directory of all of the quickstarts.

Building and running the quickstart application with a WildFly server distribution

Back Up the WildFly Standalone Server Configuration

Before you begin, back up your server configuration file.

If it is running, stop the WildFly server.
Back up the WILDFLY_HOME/standalone/configuration/standalone.xml file.

After you have completed testing this quickstart, you can replace this file to restore the server to its original configuration.

Add the Authorized Application User

This quickstart uses secured application interfaces and requires that you create the following application user to access the running application.

UserName	Realm	Password	Roles
quickstartUser	ApplicationRealm	quickstartPwd1!	Users

To add the application user, open a terminal and type the following command:

$ WILDFLY_HOME/bin/add-user.sh -a -u 'quickstartUser' -p 'quickstartPwd1!' -g 'Users'

Note	For Windows, use the `WILDFLY_HOME\bin\add-user.bat` script.

Start the WildFly Standalone Server

Open a terminal and navigate to the root of the WildFly directory.
Start the WildFly server with the default profile by typing the following command.
```
$ WILDFLY_HOME/bin/standalone.sh 
```
Note
For Windows, use the WILDFLY_HOME\bin\standalone.bat script.

Build and Deploy the Quickstart

Make sure WildFly server is started.
Open a terminal and navigate to the root directory of this quickstart.
Type the following command to build the quickstart.
```
$ mvn clean package
```
Type the following command to deploy the quickstart.
```
$ mvn wildfly:deploy
```

This deploys the http-custom-mechanism/target/http-custom-mechanism-webapp.war to the running instance of the server.

You should see a message in the server log indicating that the archive deployed successfully.

Test the Secured Servlet

Before you continue, you must test the secured servlet deployment to make sure it is working. Since this application uses a standard mechanism, it could be tested using a browser. However, after you implement the custom HTTP mechanism, the browser will not understand the request, so it is better to test the call using a client that will allow you to manipulate the headers yourself.

Issue the following command to test the deployment.

curl -v http://localhost:8080/http-custom-mechanism-webapp/secured -u quickstartUser:quickstartPwd1!

You should see the HTTP result HTTP/1.1 200 OK, along with some header information, then followed by this output.

<html>
 <head><title>Secured Servlet</title></head>
 <body>
   <h1>Secured Servlet</h1>
   <p>Current Principal 'quickstartUser'</p>
 </body>
</html>

Add the Custom Module to the Server

Now you must add the jar built by custom-module, as a custom module to the WildFly server. For your convenience, this quickstart includes the command to add the module in the add-custom-module.cli script, provided in the root directory of this quickstart.

In a terminal, navigate to the root directory of this quickstart, and run the following command, replacing WILDFLY_HOME with the path to your server.

$ WILDFLY_HOME/bin/jboss-cli.sh --connect --file=add-custom-module.cli

Note	For Windows, use the `WILDFLY_HOME\bin\jboss-cli.bat` script.

This creates the custom WILDFLY_HOME/modules/modules/org/jboss/as/quickstart/http_custom_mechanism/main folder, then copies in the custom-module/target/custom-module.jar file and creates the required module.xml file.

You can verify the module structure in your file manager.

.
└── WILDFLY_HOME
    └── modules
        └── org
            └── jboss
                └── as
                    └── quickstart
                        └── http_custom_mechanism
                            └── main
                                ├── custom-module.jar
                                └── module.xml

Configure the Server to Use the Custom Module

You configure the server to use the custom module by running CLI commands. For your convenience, this quickstart batches the commands into a configure-elytron.cli script, provided in the root directory of this quickstart.

Before you begin, make sure you have done the following:
- Back up the WildFly standalone server configuration as described above.
- Start the WildFly server with the standalone default profile as described above.
Review the configure-elytron.cli file in the root of this quickstart directory. This script adds the configuration that enables Elytron security to use the custom HTTP module created by this quickstart . Comments in the script describe the purpose of each block of commands.
Open a new terminal, navigate to the root directory of this quickstart, and run the following command, replacing WILDFLY_HOME with the path to your server.
```
$ WILDFLY_HOME/bin/jboss-cli.sh --connect --file=configure-elytron.cli
```
Note
For Windows, use the WILDFLY_HOME\bin\jboss-cli.bat script.

You should see the following result when you run the script.
```
The batch executed successfully
process-state: reload-required
```
Stop the WildFly server.

Review the Modified Server Configuration

After stopping the server, open the WILDFLY_HOME/standalone/configuration/standalone.xml file and review the changes.

The following service-loader-http-server-mechanism-factory was added to the http element of the elytron subsystem:

<http>
    <http-authentication-factory name="custom-mechanism" http-server-mechanism-factory="custom-factory" security-domain="ApplicationDomain">
        <mechanism-configuration>
            <mechanism mechanism-name="CUSTOM_MECHANISM"/>
          </mechanism-configuration>
    </http-authentication-factory>
    ...
    <service-loader-http-server-mechanism-factory name="custom-factory" module="org.jboss.as.quickstart.http_custom_mechanism.custom-http-mechanism"/>
</http>

The application-security-domain in the undertow subsystem was updated to use the custom-mechanism authentication factory with override-deployment-config set to true.

<application-security-domains>
    <application-security-domain name="other" http-authentication-factory="custom-mechanism" override-deployment-config="true"/>
</application-security-domains>

Test the Secured Servlet Using the Custom Mechanism

Now you need to test the override of the deployment with the custom HTTP mechanism, please start the server as previously described.

If you use the same curl command as when you tested the servlet before implementing the custom HTTP mechanism, it will fail with the following error.

< HTTP/1.1 401 Unauthorized
....
< X-MESSAGE: Please resubmit the request with a username specified using the X-USERNAME and a password specified using the X-PASSWORD header.

This is because the authentication mechanism rejected the call and subsequently added a header describing how to do authentication. You must modify the curl command to the following.

curl -v http://localhost:8080/http-custom-mechanism-webapp/secured -H "X-USERNAME:quickstartUser" -H "X-PASSWORD:password"

You should see the HTTP result HTTP/1.1 200 OK, along with some header information, then followed by this output.

<html>
 <head><title>Secured Servlet</title></head>
 <body>
   <h1>Secured Servlet</h1>
   <p>Current Principal 'quickstartUser'</p>
 </body>
</html>

Run the Integration Tests

This quickstart includes integration tests, which are located under the src/test/ directory. The integration tests verify that the quickstart runs correctly when deployed on the server.

Follow these steps to run the integration tests.

Make sure WildFly server is started.
Make sure the quickstart is deployed.
Type the following command to run the verify goal with the integration-testing profile activated.
```
$ mvn verify -Pintegration-testing 
```

Undeploy the Quickstart

When you are finished testing the quickstart, follow these steps to undeploy the archive.

Make sure WildFly server is started.
Open a terminal and navigate to the root directory of this quickstart.
Type this command to undeploy the archive:
```
$ mvn wildfly:undeploy
```

Restore the WildFly Standalone Server Configuration Manually

When you have completed testing the quickstart, you can restore the original server configuration by manually restoring the backup copy the configuration file.

If it is running, stop the WildFly server.
Replace the WILDFLY_HOME/standalone/configuration/standalone.xml file with the backup copy of the file.

This script reverts the changes made to the undertow and elytron subsystems. You should see the following result when you run the script.

The batch executed successfully
process-state: reload-required

Restore the WildFly Standalone Server Configuration Manually

When you have completed testing the quickstart, you can restore the original server configuration by manually restoring the backup copy the configuration file.

If it is running, stop the WildFly server.
Replace the WILDFLY_HOME/standalone/configuration/standalone.xml file with the backup copy of the file.

Building and running the quickstart application with provisioned WildFly server

Instead of using a standard WildFly server distribution, you can alternatively provision a WildFly server to deploy and run the quickstart. The functionality is provided by the WildFly Maven Plugin, and you may find its configuration in the quickstart pom.xml:

        <profile>
            <id>provisioned-server</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.wildfly.plugins</groupId>
                        <artifactId>wildfly-maven-plugin</artifactId>
                        <configuration>
                            <discover-provisioning-info>
                                <version>${version.server}</version>
                            </discover-provisioning-info>
                            <add-ons>...</add-ons>
                        </configuration>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>package</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                    ...
                </plugins>
            </build>
        </profile>

When built, the provisioned WildFly server can be found in the webapp/target/server directory, and its usage is similar to a standard server distribution, with the simplification that there is never the need to specify the server configuration to be started.

Follow these steps to run the quickstart using the provisioned server.

Procedure

Make sure the server is provisioned.
```
$ mvn clean package
```

Add the quickstart user:

$ webapp/target/server/bin/add-user.sh -a -u 'quickstartUser' -p 'quickstartPwd1!' -g 'Users'

Start the WildFly provisioned server, using the WildFly Maven Plugin start goal.
```
$ mvn -f webapp/pom.xml wildfly:start 
```
Type the following command to run the integration tests.
```
$ mvn verify -Pintegration-testing 
```
Shut down the WildFly provisioned server.
```
$ mvn -f webapp/pom.xml wildfly:shutdown
```

WildFly for OpenShift Incompatibility

This quickstart is not compatible with WildFly for OpenShift.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

README.adoc

README.adoc

http-custom-mechanism: Create a custom HTTP authorization mechanism

What is it?

System Requirements

Use of the WILDFLY_HOME and QUICKSTART_HOME Variables

Building and running the quickstart application with a WildFly server distribution

Back Up the WildFly Standalone Server Configuration

Add the Authorized Application User

Start the WildFly Standalone Server

Build and Deploy the Quickstart

Test the Secured Servlet

Add the Custom Module to the Server

Configure the Server to Use the Custom Module

Review the Modified Server Configuration

Test the Secured Servlet Using the Custom Mechanism

Run the Integration Tests

Undeploy the Quickstart

Restore the WildFly Standalone Server Configuration Manually

Restore the WildFly Standalone Server Configuration Manually

Building and running the quickstart application with provisioned WildFly server

WildFly for OpenShift Incompatibility

Files

README.adoc

Latest commit

History

README.adoc

File metadata and controls

http-custom-mechanism: Create a custom HTTP authorization mechanism

What is it?

System Requirements

Use of the WILDFLY_HOME and QUICKSTART_HOME Variables

Building and running the quickstart application with a WildFly server distribution

Back Up the WildFly Standalone Server Configuration

Add the Authorized Application User

Start the WildFly Standalone Server

Build and Deploy the Quickstart

Test the Secured Servlet

Add the Custom Module to the Server

Configure the Server to Use the Custom Module

Review the Modified Server Configuration

Test the Secured Servlet Using the Custom Mechanism

Run the Integration Tests

Undeploy the Quickstart

Restore the WildFly Standalone Server Configuration Manually

Restore the WildFly Standalone Server Configuration Manually

Building and running the quickstart application with provisioned WildFly server

WildFly for OpenShift Incompatibility