Merge branch 'feature/jwks-endpoint' of gremlin/lti-demo-cmr into develop

pom.xml

@@ -79,12 +79,6 @@
 			<groupId>org.springframework.integration</groupId>
 			<artifactId>spring-integration-redis</artifactId>
 		</dependency>
-		<dependency>
-			<groupId>org.projectlombok</groupId>
-			<artifactId>lombok</artifactId>
-			<optional>true</optional>
-		</dependency>
-
 		<dependency>
 			<groupId>org.springframework.integration</groupId>
 			<artifactId>spring-integration-test</artifactId>

src/main/java/riomhaire/lti/JavaLti13ToolApplication.java

@@ -8,15 +8,22 @@ import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.lang.NonNull;
 import org.springframework.web.servlet.ModelAndView;
 import riomhaire.lti.core.business.LTIMessageDispatcher;
+import riomhaire.lti.core.business.commands.BuildJWKSResponseCommand;
 import riomhaire.lti.core.business.commands.InitiateOidcCommand;
 import riomhaire.lti.core.business.commands.LTILaunchCommand;
 import riomhaire.lti.core.business.commands.LaunchContentCommand;
-import riomhaire.lti.core.infrastructure.facades.clientregistration.RedisBasedClientRegistrationResolver;
+import riomhaire.lti.core.infrastructure.facades.configuration.clientregistration.RedisBasedClientRegistrationResolver;
+import riomhaire.lti.core.infrastructure.facades.configuration.tool.RedisBasedToolConfigurationResolver;
 import riomhaire.lti.core.model.LTIMessage;
 import riomhaire.lti.core.model.LTIMessageType;
+import riomhaire.lti.core.model.configuration.ClientConfiguration;
+import riomhaire.lti.core.model.configuration.ToolConfiguration;
 import riomhaire.lti.core.model.interfaces.ApplicationRegistry;
-import riomhaire.lti.core.model.interfaces.ClientRegistrationResolver;
 import riomhaire.lti.core.model.interfaces.CommandDispatcher;
+import riomhaire.lti.core.model.interfaces.NoKeyResolver;
+import riomhaire.lti.core.model.interfaces.UniKeyResolver;
+
+import java.util.Optional;
 
 /**
  * This is the main entry point for the LTI Tool and well as salient configuration of core important items.
@@ -45,10 +52,18 @@ public class JavaLti13ToolApplication {
      * @return ClientRegistrationResolver which allows us to look up a client registration based on certain parameters
      */
     @Bean
-    ClientRegistrationResolver buildClientRegistrationResolver(RedisTemplate<String, String> template) {
+    UniKeyResolver<Optional<ClientConfiguration>, String> buildClientRegistrationResolver(RedisTemplate<String, String> template) {
         return new RedisBasedClientRegistrationResolver(template);
     }
 
+    /**
+     *
+     */
+    @Bean
+    NoKeyResolver<Optional<ToolConfiguration>> buildToolConfigurationResolver(RedisTemplate<String, String> template) {
+        return new RedisBasedToolConfigurationResolver(template,"lti-tool-configuration");
+    }
+
     /**
      * This Spring bean creates the command dispatcher and populates it for the current tool .
      * It is here where you map messageType to command which handles it
@@ -68,7 +83,8 @@ public class JavaLti13ToolApplication {
         return new LTIMessageDispatcher()
                 .addCommand(LTIMessageType.ProcessOidcRequest.name(), new InitiateOidcCommand())
                 .addCommand(LTIMessageType.ProcessLTIMessage.name(), new LTILaunchCommand())
-                .addCommand(LTIMessageType.LaunchContent.name(), new LaunchContentCommand());
+                .addCommand(LTIMessageType.LaunchContent.name(), new LaunchContentCommand())
+                .addCommand(LTIMessageType.BuildJWKSResponse.name(), new BuildJWKSResponseCommand());
 
     }
 
@@ -77,11 +93,12 @@ public class JavaLti13ToolApplication {
      *
      * @param commandDispatcher            Dispatches a message to an appropriate command
      * @param clientRegistrationResolver   Look up the configuration for a particular client
+     * @param toolConfigurationResolver    Where we can find the config
      * @return Registry            environment links  we execute within
      */
     @Bean
-    public Registry buildRegistry(@NonNull CommandDispatcher<ModelAndView, ApplicationRegistry<ModelAndView,LTIMessage>, LTIMessage> commandDispatcher, @NonNull ClientRegistrationResolver clientRegistrationResolver) {
-        return new Registry(commandDispatcher, clientRegistrationResolver);
+    public Registry buildRegistry(@NonNull CommandDispatcher<ModelAndView, ApplicationRegistry<ModelAndView, LTIMessage>, LTIMessage> commandDispatcher, @NonNull UniKeyResolver<Optional<ClientConfiguration>, String> clientRegistrationResolver, NoKeyResolver<Optional<ToolConfiguration>> toolConfigurationResolver) {
+        return new Registry(commandDispatcher, clientRegistrationResolver, toolConfigurationResolver);
     }
 
 }

src/main/java/riomhaire/lti/Registry.java

@@ -1,11 +1,16 @@
 package riomhaire.lti;
 
-import lombok.AllArgsConstructor;
+
 import org.springframework.web.servlet.ModelAndView;
 import riomhaire.lti.core.model.LTIMessage;
+import riomhaire.lti.core.model.configuration.ClientConfiguration;
+import riomhaire.lti.core.model.configuration.ToolConfiguration;
 import riomhaire.lti.core.model.interfaces.ApplicationRegistry;
-import riomhaire.lti.core.model.interfaces.ClientRegistrationResolver;
 import riomhaire.lti.core.model.interfaces.CommandDispatcher;
+import riomhaire.lti.core.model.interfaces.NoKeyResolver;
+import riomhaire.lti.core.model.interfaces.UniKeyResolver;
+
+import java.util.Optional;
 
 /**
  *  ApplicationRegistry is the 'environment' within which commands ... it should contain things like
@@ -16,24 +21,48 @@ import riomhaire.lti.core.model.interfaces.CommandDispatcher;
  *  The Environment os specific to the message that the command processes and the responses they generate.
  *  In this model all commands take the same message model and return the same consistent model.
  */
-@AllArgsConstructor
+
 public class Registry implements ApplicationRegistry<ModelAndView,LTIMessage> {
 
     // This is the command dispatcher
     private final CommandDispatcher<ModelAndView, ApplicationRegistry<ModelAndView,LTIMessage>, LTIMessage> commandDispatcher;
     // We need somewhere to read a tool/partner integration from - this service proxy performs that role.
-    private final ClientRegistrationResolver clientRegistrationResolver;
+    private final UniKeyResolver<Optional<ClientConfiguration>, String> clientRegistrationResolver;
+    // This is where most of the tools config is stored
+    private final NoKeyResolver<Optional<ToolConfiguration>> toolConfigurationResolver;
 
+    /**
+     * Constructor contains all the services and objects to run the application
+     * @param commandDispatcher
+     * @param clientRegistrationResolver
+     * @param toolConfigurationResolver
+     */
+    public Registry(CommandDispatcher<ModelAndView, ApplicationRegistry<ModelAndView, LTIMessage>, LTIMessage> commandDispatcher, UniKeyResolver<Optional<ClientConfiguration>, String> clientRegistrationResolver, NoKeyResolver<Optional<ToolConfiguration>> toolConfigurationResolver) {
+        this.commandDispatcher = commandDispatcher;
+        this.clientRegistrationResolver = clientRegistrationResolver;
+        this.toolConfigurationResolver = toolConfigurationResolver;
+    }
 
     /**
      *  Return the current client configuration resolver
      * @return     ClientRegistrationResolver
      */
     @Override
-    public ClientRegistrationResolver clientRegistrationResolver() {
+    public UniKeyResolver<Optional<ClientConfiguration>, String> clientRegistrationResolver() {
         return clientRegistrationResolver;
     }
 
+    /**
+     * Return the current tool configuration resolver
+     * This is where most of the tool configuration is stored -  keys, secrets etc
+     *
+     * @return ClientRegistrationResolver
+     */
+    @Override
+    public NoKeyResolver<Optional<ToolConfiguration>> toolConfigurationResolver() {
+        return toolConfigurationResolver;
+    }
+
     /**
      * Returns access to the current command dispatcher
      *

src/main/java/riomhaire/lti/core/adapters/token/JWKBasedJwtToMapAdapter.java

@@ -1,14 +1,13 @@
 package riomhaire.lti.core.adapters.token;
 
 import com.auth0.jwt.JWT;
-import com.auth0.jwt.interfaces.DecodedJWT;
-import lombok.extern.slf4j.Slf4j;
 import org.jose4j.jwk.HttpsJwks;
 import org.jose4j.jwt.JwtClaims;
 import org.jose4j.jwt.consumer.InvalidJwtException;
-import org.jose4j.jwt.consumer.JwtConsumer;
 import org.jose4j.jwt.consumer.JwtConsumerBuilder;
 import org.jose4j.keys.resolvers.HttpsJwksVerificationKeyResolver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import riomhaire.lti.core.model.interfaces.DecodeException;
 import riomhaire.lti.core.model.interfaces.Decoder;
 
@@ -17,13 +16,14 @@ import java.util.Map;
 /**
  * This class is a helper class which takes a JWT token an verifies it is valid based on the jwk link provided
  */
-@Slf4j
+
 public class JWKBasedJwtToMapAdapter implements Decoder<Map<String, Object>, String> {
     // Issuer JWKS endpoint
     protected final String jwksUrl;
     // True if we dont want to actually verify the token
     protected final boolean skipVerification;
-
+    // Logger
+    Logger log = LoggerFactory.getLogger(this.getClass());
     /**
      * Constructor
      * @param jwksUrl  - the issuer endpoint where jwks is returned
@@ -41,19 +41,16 @@ public class JWKBasedJwtToMapAdapter implements Decoder<Map<String, Object>, Str
      * @throws DecodeException if there is something wrong - invalid token etc
      */
     public Map<String, Object> decode(String token) throws DecodeException {
-        DecodedJWT jwt = JWT.decode(token);
+        var jwt = JWT.decode(token);
         JwtClaims verifiedClaims;
-
-
-        String clientId = jwt.getClaim("aud").asString();
-
+        var clientId = jwt.getClaim("aud").asString();
 
         try {
             // OK look up jwks and verify
             log.trace("Using key:" + jwt.getKeyId() + " to search: " + jwksUrl);
-            HttpsJwks httpsJkws = new HttpsJwks(jwksUrl);
-            HttpsJwksVerificationKeyResolver httpsJwksKeyResolver = new HttpsJwksVerificationKeyResolver(httpsJkws);
-            JwtConsumer jwtConsumer = new JwtConsumerBuilder()
+            var httpsJkws = new HttpsJwks(jwksUrl);
+            var httpsJwksKeyResolver = new HttpsJwksVerificationKeyResolver(httpsJkws);
+            var jwtConsumer = new JwtConsumerBuilder()
                     .setVerificationKeyResolver(httpsJwksKeyResolver)
                     .setExpectedAudience(clientId)
                     .build();

src/main/java/riomhaire/lti/core/business/LTIMessageDispatcher.java

@@ -1,7 +1,5 @@
 package riomhaire.lti.core.business;
 
-import lombok.NoArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
 import org.springframework.web.servlet.ModelAndView;
 import riomhaire.lti.core.model.LTIMessage;
 import riomhaire.lti.core.model.interfaces.ApplicationRegistry;
@@ -15,8 +13,6 @@ import java.util.HashMap;
  * we map a message to one command handler. This allows us to decouple the handler of the message from the sender.
  * We could extend this where necessary
  */
-@Slf4j
-@NoArgsConstructor
 public class LTIMessageDispatcher implements CommandDispatcher<ModelAndView, ApplicationRegistry<ModelAndView,LTIMessage>, LTIMessage> {
     // This stores the mapping of command to command handler
     private final HashMap<String, Command<ModelAndView, ApplicationRegistry<ModelAndView,LTIMessage>, LTIMessage>> commands = new HashMap<>();
@@ -24,6 +20,7 @@ public class LTIMessageDispatcher implements CommandDispatcher<ModelAndView, App
     // This is the action that is (optionally) executed if no match is made
     private Command<ModelAndView, ApplicationRegistry<ModelAndView,LTIMessage>, LTIMessage> defaultCommand;
 
+
     /**
      * This adds a mapping of a message type to the command that can handle that type
      * At the moment its a 1-1 mapping

src/main/java/riomhaire/lti/core/business/commands/BuildJWKSResponseCommand.java

@@ -0,0 +1,82 @@
+package riomhaire.lti.core.business.commands;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.jose4j.jwk.JsonWebKey;
+import org.jose4j.jwk.JsonWebKeySet;
+import org.jose4j.jwk.PublicJsonWebKey;
+import org.jose4j.jwk.RsaJsonWebKey;
+import org.jose4j.keys.RsaKeyUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
+import riomhaire.lti.core.model.LTIMessage;
+import riomhaire.lti.core.model.configuration.JWKKey;
+import riomhaire.lti.core.model.interfaces.ApplicationRegistry;
+import riomhaire.lti.core.model.interfaces.Command;
+
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Date;
+import java.util.HashMap;
+
+/**
+ * The type Build jwks response command.
+ */
+public class BuildJWKSResponseCommand  implements Command<ModelAndView, ApplicationRegistry<ModelAndView, LTIMessage>, LTIMessage> {
+    // Logger
+    private Logger log = LoggerFactory.getLogger(this.getClass());
+
+    /**
+     * This is the signature a message processing command can implement when invoked by the dispatcher
+     *
+     * @param environment - usually some form of application registry
+     * @param message     - what message format the command will get
+     * @return some response
+     */
+    @Override
+    public ModelAndView execute(ApplicationRegistry<ModelAndView, LTIMessage> environment, LTIMessage message) {
+        ModelAndView mav;
+        var objectMapper = new ObjectMapper();
+        try {
+            // Step 1 - retrieve config
+            var optionalConfiguration =  environment.toolConfigurationResolver().lookup();
+            if( optionalConfiguration.isEmpty() ) throw new FileNotFoundException("No Tool Configuration has been set");
+
+
+            // Step 2 - build jwks compliant data structure
+            var webKeys = new ArrayList<RsaJsonWebKey>();
+            var toolConfiguration = optionalConfiguration.get();
+            var jwkKeys = toolConfiguration.getJwkKeys();
+            // Step 2.1 - Convert public key from base64 String and convert to PEM
+            // For each known key
+            for( JWKKey configKeyEntry : jwkKeys ){
+                var pemString =  new String(Base64.getDecoder().decode(configKeyEntry.getPublicKey()));
+                var rsaJsonWebKey = (RsaJsonWebKey) PublicJsonWebKey.Factory.newPublicJwk(new RsaKeyUtil().fromPemEncoded(pemString));
+                rsaJsonWebKey.setKeyId(configKeyEntry.getKeyId());
+                webKeys.add(rsaJsonWebKey);
+            }
+            // Conveluted  hack
+            var jwks = new JsonWebKeySet(webKeys);
+            var raw = objectMapper.readValue(jwks.toJson(JsonWebKey.OutputControlLevel.PUBLIC_ONLY), HashMap.class);
+            // Step 3 - render as json response
+
+            var view = new MappingJackson2JsonView();
+            view.setPrettyPrint(true);
+            mav = new ModelAndView(view);
+            mav.addAllObjects(raw);
+
+        } catch (Exception ex) {
+            log.error(ex.getMessage());
+            mav = new ModelAndView("error");
+            mav.addObject("timestamp", new Date());
+            mav.addObject("error", ex.getMessage());
+            mav.addObject("path", "/jwks");
+            mav.addObject("queryParameters", message.getQueryParams());
+
+        }
+
+        return mav;
+    }
+}

src/main/java/riomhaire/lti/core/business/commands/InitiateOidcCommand.java

@@ -1,36 +1,41 @@
 package riomhaire.lti.core.business.commands;
 
-import lombok.AllArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.web.servlet.ModelAndView;
 import org.springframework.web.servlet.view.RedirectView;
-import org.springframework.web.servlet.view.json.MappingJackson2JsonView;
 import riomhaire.lti.core.model.LTIMessage;
 import riomhaire.lti.core.model.interfaces.ApplicationRegistry;
 import riomhaire.lti.core.model.interfaces.Command;
 
+import java.util.Date;
 import java.util.UUID;
 
 /**
  * Defines  execute command on message P within environment E returning T
  *
- * @param <T> What object is returned by the command
- * @param <E> WHat execution environment is to be used (usually some form of Application Registry)
- * @param <P> The message the command can process
  *
  * This implementation is for the OIDC Initiation call made by an issuer as part of the security specification.
  */
-@AllArgsConstructor
-@Slf4j
 public class InitiateOidcCommand implements Command<ModelAndView, ApplicationRegistry<ModelAndView,LTIMessage>, LTIMessage> {
+    // Logger
+    private Logger log = LoggerFactory.getLogger(this.getClass());
 
 
+    /**
+     * THis command handles the initiate OIDC launch sequence
+     *
+     * @param registry the environment
+     * @param message - what message format the command will get
+     * @return
+     *
+     */
     public ModelAndView execute(ApplicationRegistry<ModelAndView,LTIMessage> registry, LTIMessage message) {
         final ModelAndView mav;
         var queryParams = message.getQueryParams();
         String iss = queryParams.get("iss");
         String clientId = queryParams.get("client_id");
-        var clientRegistration = registry.clientRegistrationResolver().lookupClient(iss, clientId);
+        var clientRegistration = registry.clientRegistrationResolver().lookup(String.format("%s%s",iss, clientId));
 
         if (clientRegistration.isPresent()) {
             // Build Location
@@ -67,13 +72,21 @@ public class InitiateOidcCommand implements Command<ModelAndView, ApplicationReg
         } else {
             String msg = "unknown issuer [" + iss + "] client [" + clientId + "]";
             log.error(msg);
-            MappingJackson2JsonView view = new MappingJackson2JsonView();
-            view.setPrettyPrint(true);
-            mav = new ModelAndView(view);
+            mav = new ModelAndView("error");
+            mav.addObject("timestamp", new Date());
             mav.addObject("error", msg);
-            mav.addObject("queryParams", queryParams);
+            mav.addObject("path", "/oidc");
+            mav.addObject("queryParameters", message.getQueryParams());
+
         }
         return mav;
 
     }
+
+
+    /**
+     * Default constructor
+     */
+    public InitiateOidcCommand() {
+    }
 }

src/main/java/riomhaire/lti/core/business/commands/LTILaunchCommand.java

@@ -1,13 +1,13 @@
 package riomhaire.lti.core.business.commands;
 
 import com.auth0.jwt.JWT;
-import lombok.AllArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.web.servlet.ModelAndView;
 import riomhaire.lti.core.adapters.token.JWKBasedJwtToMapAdapter;
-import riomhaire.lti.core.model.ClientConfiguration;
 import riomhaire.lti.core.model.LTIMessage;
 import riomhaire.lti.core.model.LTIMessageType;
+import riomhaire.lti.core.model.configuration.ClientConfiguration;
 import riomhaire.lti.core.model.interfaces.ApplicationRegistry;
 import riomhaire.lti.core.model.interfaces.Command;
 import riomhaire.lti.core.model.interfaces.DecodeException;
@@ -18,19 +18,16 @@ import java.util.Map;
 /**
  * Defines  execute command on message P within environment E returning T
  *
- * @param <T> What object is returned by the command
- * @param <E> WHat execution environment is to be used (usually some form of Application Registry)
- * @param <P> The message the command can process
  *
  * Processes lti launch content and create deep link messages - IE claims within a JWT
  * Delegates to the actual handler  depending on if its just a launch or a create-deep-link launch
  */
-@AllArgsConstructor
-@Slf4j
 public class LTILaunchCommand implements Command<ModelAndView, ApplicationRegistry<ModelAndView,LTIMessage>, LTIMessage> {
     public static final String CLAIM_MESSAGE_TYPE = "https://purl.imsglobal.org/spec/lti/claim/message_type";
     public static final String LTI_RESOURCE_LINK_REQUEST = "LtiResourceLinkRequest";
     public static final String LTI_DEEP_LINKING_REQUEST = "LtiDeepLinkingRequest";
+    // Logger
+    Logger log = LoggerFactory.getLogger(this.getClass());
 
     @Override
     public ModelAndView execute(ApplicationRegistry<ModelAndView,LTIMessage> registry, LTIMessage message) {
@@ -43,7 +40,7 @@ public class LTILaunchCommand implements Command<ModelAndView, ApplicationRegist
         var issuer = jwt.getClaim("iss").asString();
         var clientId = jwt.getClaim("aud").asString();
 
-        var toolRegistration = registry.clientRegistrationResolver().lookupClient(issuer, clientId);
+        var toolRegistration = registry.clientRegistrationResolver().lookup(String.format("%s%s",issuer, clientId));
         var claims = new HashMap<String,Object>();
         if( toolRegistration.isPresent()) {
             claims.putAll(decodeToken(token, issuer, clientId, toolRegistration.get()));

src/main/java/riomhaire/lti/core/infrastructure/api/Endpoint.java

@@ -1,6 +1,7 @@
 package riomhaire.lti.core.infrastructure.api;
 
-import lombok.Getter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.servlet.ModelAndView;
 import riomhaire.lti.core.model.LTIMessage;
@@ -9,10 +10,13 @@ import riomhaire.lti.core.model.interfaces.CommandDispatcher;
 
 import javax.annotation.PostConstruct;
 
-@Getter
 public class Endpoint {
+    // Logger
+    protected Logger log = LoggerFactory.getLogger(this.getClass());
+
     @Autowired
     private ApplicationRegistry registry;
+
     private CommandDispatcher<ModelAndView, ApplicationRegistry, LTIMessage> dispatcher;
 
     @PostConstruct
@@ -20,4 +24,17 @@ public class Endpoint {
         dispatcher = registry.commandDispatcher();
     }
 
+    /**
+     * Return the dispatcher
+     * @return
+     */
+    public CommandDispatcher<ModelAndView, ApplicationRegistry, LTIMessage> getDispatcher() {
+        return dispatcher;
+    }
+
+
+    public ApplicationRegistry getRegistry() {
+        return registry;
+    }
+
 }

src/main/java/riomhaire/lti/core/infrastructure/api/tool/JwksEndpoint.java

@@ -0,0 +1,27 @@
+package riomhaire.lti.core.infrastructure.api.tool;
+
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.servlet.ModelAndView;
+import riomhaire.lti.core.infrastructure.api.Endpoint;
+import riomhaire.lti.core.model.LTIMessage;
+import riomhaire.lti.core.model.LTIMessageType;
+
+import java.util.Map;
+
+@RestController
+public class JwksEndpoint  extends Endpoint {
+
+    @RequestMapping(path = "/jwks")
+    public ModelAndView oidc(@RequestParam Map<String, String> queryParams, @RequestHeader Map<String, Object> headers) {
+
+        var message = LTIMessage.builder()
+                .messageType(LTIMessageType.BuildJWKSResponse.name())
+                .metadata(headers)
+                .queryParams(queryParams)
+                .build();
+        return getDispatcher().dispatch(getRegistry(), message);
+    }
+}

src/main/java/riomhaire/lti/core/infrastructure/api/tool/LaunchEndpoint.java

@@ -1,6 +1,5 @@
 package riomhaire.lti.core.infrastructure.api.tool;
 
-import lombok.extern.slf4j.Slf4j;
 import org.springframework.web.bind.annotation.RequestHeader;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
@@ -14,7 +13,6 @@ import java.util.Map;
 
 
 @RestController
-@Slf4j
 public class LaunchEndpoint extends Endpoint {
 
 

src/main/java/riomhaire/lti/core/infrastructure/api/tool/OIDCEndpoint.java

@@ -1,6 +1,5 @@
 package riomhaire.lti.core.infrastructure.api.tool;
 
-import lombok.extern.slf4j.Slf4j;
 import org.springframework.web.bind.annotation.RequestHeader;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
@@ -13,7 +12,7 @@ import riomhaire.lti.core.model.LTIMessageType;
 import java.util.Map;
 
 @RestController
-@Slf4j
+
 public class OIDCEndpoint extends Endpoint {
 
 

src/main/java/riomhaire/lti/core/infrastructure/configuration/DecoupledLogicSetup.java

@@ -1,11 +1,10 @@
 package riomhaire.lti.core.infrastructure.configuration;
 
-import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver;
 
-@Slf4j
+
 @Configuration
 public class DecoupledLogicSetup {
     @Bean

src/main/java/riomhaire/lti/core/infrastructure/facades/clientregistration/ConfigBasedClientRegistrationResolver.java

@@ -1,28 +0,0 @@
-package riomhaire.lti.core.infrastructure.facades.clientregistration;
-
-
-import riomhaire.lti.core.model.ClientConfiguration;
-import riomhaire.lti.core.model.interfaces.ClientRegistrationResolver;
-
-import java.util.Optional;
-
-/**
- *  When a tool/partner-lms is registered we need to store this information somewhere ... and we have
- *  abstracted this out as a  'ClientRegistrationResolver'. Implementations of this interface  could be
- *  to a file, DB or Redis - but all the call wants to know about is I want to find out about this deployment
- *
- * This is a config file based implementation
- */
- public class ConfigBasedClientRegistrationResolver implements ClientRegistrationResolver {
-
-    /**
-     * Return the registration information related to this issuer/client-id pair
-     * @param issuer    ... This is canvas/blackboard or some other entity
-     * @param clientId  ... This is a particular tool within the issuer environment
-     * @return  ClientConfiguration if found
-     */
-    @Override
-    public Optional<ClientConfiguration> lookupClient(String issuer, String clientId) {
-        return Optional.empty();
-    }
-}

src/main/java/riomhaire/lti/core/infrastructure/facades/clientregistration/RedisBasedClientRegistrationResolver.java

@@ -1,51 +0,0 @@
-package riomhaire.lti.core.infrastructure.facades.clientregistration;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import lombok.SneakyThrows;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.util.DigestUtils;
-import riomhaire.lti.core.model.ClientConfiguration;
-import riomhaire.lti.core.model.interfaces.ClientRegistrationResolver;
-
-import java.util.Optional;
-
-
-/**
- *  When a tool/partner-lms is registered we need to store this information somewhere ... and we have
- *  abstracted this out as a  'ClientRegistrationResolver'. Implementations of this interface  could be
- *  to a file, DB or Redis - but all the call wants to know about is I want to find out about this deployment
- *
- *  This implementation is for Redis
- */
-public class RedisBasedClientRegistrationResolver implements ClientRegistrationResolver {
-    final ObjectMapper objectMapper = new ObjectMapper();
-    private final RedisTemplate<String, String> template;
-
-    /**
-     *
-     * @param template THe spring redis template
-     */
-    public RedisBasedClientRegistrationResolver(RedisTemplate<String, String> template) {
-        this.template = template;
-    }
-
-    /**
-     * Return the registration information related to this issuer/client-id pair
-     * @param issuer    ... This is canvas/blackboard or some other entity
-     * @param clientId  ... This is a particular tool within the issuer environment
-     * @return  ClientConfiguration if found
-     */
-    @SneakyThrows
-    @Override
-    public Optional<ClientConfiguration> lookupClient(String issuer, String clientId) {
-        var hash = DigestUtils.md5DigestAsHex((issuer + clientId).getBytes());
-        var key = String.format("lti-client-registration-%s", hash);
-        var blob = template.opsForValue().get(key);
-
-        if (blob != null) {
-            ClientConfiguration client = objectMapper.readValue(blob, ClientConfiguration.class);
-            return Optional.of(client);
-        }
-        return Optional.empty();
-    }
-}

src/main/java/riomhaire/lti/core/infrastructure/facades/configuration/clientregistration/RedisBasedClientRegistrationResolver.java

@@ -0,0 +1,57 @@
+package riomhaire.lti.core.infrastructure.facades.configuration.clientregistration;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.util.DigestUtils;
+import riomhaire.lti.core.model.configuration.ClientConfiguration;
+import riomhaire.lti.core.model.interfaces.UniKeyResolver;
+
+import java.util.Optional;
+
+
+/**
+ * When a tool/partner-lms is registered we need to store this information somewhere ... and we have
+ * abstracted this out as a  'ClientRegistrationResolver'. Implementations of this interface  could be
+ * to a file, DB or Redis - but all the call wants to know about is I want to find out about this deployment
+ * <p>
+ * This implementation is for Redis
+ */
+public class RedisBasedClientRegistrationResolver implements UniKeyResolver<Optional<ClientConfiguration>, String> {
+    final ObjectMapper objectMapper = new ObjectMapper();
+    private final RedisTemplate<String, String> template;
+    // Logger
+    private Logger log = LoggerFactory.getLogger(this.getClass());
+
+    /**
+     * @param template THe spring redis template
+     */
+    public RedisBasedClientRegistrationResolver(RedisTemplate<String, String> template) {
+        this.template = template;
+    }
+
+    /**
+     * Return the registration information related to this issuer/client-id pair
+     *
+     * @param key ... This is canvas/blackboard or some other entity
+     * @return ClientConfiguration if found
+     */
+    @Override
+    public Optional<ClientConfiguration> lookup(String key) {
+        try {
+            var hash = DigestUtils.md5DigestAsHex((key).getBytes());
+            var actualKey = String.format("lti-client-registration-%s", hash);
+            var blob = template.opsForValue().get(actualKey);
+
+            if (blob != null) {
+                return Optional.of(objectMapper.readValue(blob, ClientConfiguration.class));
+            }
+
+        } catch (Exception e) {
+            log.error(e.getMessage());
+            // Return not there
+        }
+        return Optional.empty();
+    }
+}

src/main/java/riomhaire/lti/core/infrastructure/facades/configuration/tool/RedisBasedToolConfigurationResolver.java

@@ -0,0 +1,56 @@
+package riomhaire.lti.core.infrastructure.facades.configuration.tool;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import riomhaire.lti.core.model.configuration.ToolConfiguration;
+import riomhaire.lti.core.model.interfaces.NoKeyResolver;
+
+import java.util.Optional;
+
+/**
+ * This reads this tools configuration
+ */
+public class RedisBasedToolConfigurationResolver  implements NoKeyResolver<Optional<ToolConfiguration>> {
+
+    final ObjectMapper objectMapper = new ObjectMapper();
+    private final RedisTemplate<String, String> template;
+   // This is what key to lookup
+    private  String key = "lti-tool-configuration";
+    // Logger
+    private Logger log = LoggerFactory.getLogger(this.getClass());
+
+    /**
+     * All args constructor
+
+     * @param template THe spring redis template
+     * @param redisKey the key in redis where config is stored.
+     */
+    public RedisBasedToolConfigurationResolver(RedisTemplate<String, String> template,String redisKey) {
+        this.template = template;
+        this.key=redisKey;
+    }
+
+    /**
+     * Return information associated with the implementor
+     *
+     * @return object if found
+     */
+    @Override
+    public Optional<ToolConfiguration> lookup() {
+        try {
+            var blob = template.opsForValue().get(key);
+
+            if (blob != null) {
+                return Optional.of(objectMapper.readValue(blob, ToolConfiguration.class));
+            }
+
+        } catch(Exception e) {
+          log.error(e.getMessage());
+          // return empty
+        }
+        return Optional.empty();
+
+    }
+}

src/main/java/riomhaire/lti/core/model/ClientConfiguration.java

@@ -1,23 +0,0 @@
-package riomhaire.lti.core.model;
-
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonInclude;
-import lombok.Data;
-
-import java.util.List;
-
-@Data
-@JsonInclude(JsonInclude.Include.NON_NULL)
-@JsonIgnoreProperties(ignoreUnknown = true)
-public class ClientConfiguration {
-    String id;            // Hash of issuer and clientid
-    String name;          // Name of the tool installation
-    String issuer;        // WHo issued the request - usually the LMS
-    String clientId;      // Tool Client ID
-    String jwksUrl;       // Where the public key for the issuer can be found
-    String authenticateUrl;  // The call back authentication url
-    boolean skipVerification;          // If true then skip token verification
-    List<String> deployments; // List of specific deployments of this client
-
-}

src/main/java/riomhaire/lti/core/model/LTIMessage.java

@@ -1,15 +1,135 @@
 package riomhaire.lti.core.model;
 
-import lombok.Builder;
-import lombok.Data;
-
 import java.util.Map;
 
-@Builder
-@Data
 public class LTIMessage {
     private String messageType;
     private Map<String, Object> metadata;
     private Map<String, String> queryParams;
     private Map<String, Object> claims;
+
+    LTIMessage(String messageType, Map<String, Object> metadata, Map<String, String> queryParams, Map<String, Object> claims) {
+        this.messageType = messageType;
+        this.metadata = metadata;
+        this.queryParams = queryParams;
+        this.claims = claims;
+    }
+
+    public static LTIMessageBuilder builder() {
+        return new LTIMessageBuilder();
+    }
+
+    public String getMessageType() {
+        return this.messageType;
+    }
+
+    public Map<String, Object> getMetadata() {
+        return this.metadata;
+    }
+
+    public Map<String, String> getQueryParams() {
+        return this.queryParams;
+    }
+
+    public Map<String, Object> getClaims() {
+        return this.claims;
+    }
+
+    public void setMessageType(String messageType) {
+        this.messageType = messageType;
+    }
+
+    public void setMetadata(Map<String, Object> metadata) {
+        this.metadata = metadata;
+    }
+
+    public void setQueryParams(Map<String, String> queryParams) {
+        this.queryParams = queryParams;
+    }
+
+    public void setClaims(Map<String, Object> claims) {
+        this.claims = claims;
+    }
+
+    public boolean equals(final Object o) {
+        if (o == this) return true;
+        if (!(o instanceof LTIMessage)) return false;
+        final LTIMessage other = (LTIMessage) o;
+        if (!other.canEqual((Object) this)) return false;
+        final Object this$messageType = this.getMessageType();
+        final Object other$messageType = other.getMessageType();
+        if (this$messageType == null ? other$messageType != null : !this$messageType.equals(other$messageType))
+            return false;
+        final Object this$metadata = this.getMetadata();
+        final Object other$metadata = other.getMetadata();
+        if (this$metadata == null ? other$metadata != null : !this$metadata.equals(other$metadata)) return false;
+        final Object this$queryParams = this.getQueryParams();
+        final Object other$queryParams = other.getQueryParams();
+        if (this$queryParams == null ? other$queryParams != null : !this$queryParams.equals(other$queryParams))
+            return false;
+        final Object this$claims = this.getClaims();
+        final Object other$claims = other.getClaims();
+        if (this$claims == null ? other$claims != null : !this$claims.equals(other$claims)) return false;
+        return true;
+    }
+
+    protected boolean canEqual(final Object other) {
+        return other instanceof LTIMessage;
+    }
+
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        final Object $messageType = this.getMessageType();
+        result = result * PRIME + ($messageType == null ? 43 : $messageType.hashCode());
+        final Object $metadata = this.getMetadata();
+        result = result * PRIME + ($metadata == null ? 43 : $metadata.hashCode());
+        final Object $queryParams = this.getQueryParams();
+        result = result * PRIME + ($queryParams == null ? 43 : $queryParams.hashCode());
+        final Object $claims = this.getClaims();
+        result = result * PRIME + ($claims == null ? 43 : $claims.hashCode());
+        return result;
+    }
+
+    public String toString() {
+        return "LTIMessage(messageType=" + this.getMessageType() + ", metadata=" + this.getMetadata() + ", queryParams=" + this.getQueryParams() + ", claims=" + this.getClaims() + ")";
+    }
+
+    public static class LTIMessageBuilder {
+        private String messageType;
+        private Map<String, Object> metadata;
+        private Map<String, String> queryParams;
+        private Map<String, Object> claims;
+
+        LTIMessageBuilder() {
+        }
+
+        public LTIMessageBuilder messageType(String messageType) {
+            this.messageType = messageType;
+            return this;
+        }
+
+        public LTIMessageBuilder metadata(Map<String, Object> metadata) {
+            this.metadata = metadata;
+            return this;
+        }
+
+        public LTIMessageBuilder queryParams(Map<String, String> queryParams) {
+            this.queryParams = queryParams;
+            return this;
+        }
+
+        public LTIMessageBuilder claims(Map<String, Object> claims) {
+            this.claims = claims;
+            return this;
+        }
+
+        public LTIMessage build() {
+            return new LTIMessage(messageType, metadata, queryParams, claims);
+        }
+
+        public String toString() {
+            return "LTIMessage.LTIMessageBuilder(messageType=" + this.messageType + ", metadata=" + this.metadata + ", queryParams=" + this.queryParams + ", claims=" + this.claims + ")";
+        }
+    }
 }

src/main/java/riomhaire/lti/core/model/LTIMessageType.java

@@ -4,5 +4,6 @@ public enum LTIMessageType {
     LaunchContent,
     ProcessLTIMessage,
     ProcessOidcRequest,
-    SelectDeepLinkContent
+    SelectDeepLinkContent,
+    BuildJWKSResponse
 }

src/main/java/riomhaire/lti/core/model/configuration/ClientConfiguration.java

@@ -0,0 +1,153 @@
+package riomhaire.lti.core.model.configuration;
+
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import java.util.List;
+
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class ClientConfiguration {
+    String id;            // Hash of issuer and clientid
+    String name;          // Name of the tool installation
+    String issuer;        // WHo issued the request - usually the LMS
+    String clientId;      // Tool Client ID
+    String jwksUrl;       // Where the public key for the issuer can be found
+    String authenticateUrl;  // The call back authentication url
+    boolean skipVerification;          // If true then skip token verification
+    List<String> deployments; // List of specific deployments of this client
+
+    /**
+     * Default constructor
+     */
+    public ClientConfiguration() {
+    }
+
+    /**
+     * @return
+     */
+    public String getId() {
+        return id;
+    }
+
+    /**
+     *
+     * @param id
+     */
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     *
+     * @param name
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public String getIssuer() {
+        return issuer;
+    }
+
+    /**
+     *
+     * @param issuer
+     */
+    public void setIssuer(String issuer) {
+        this.issuer = issuer;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public String getClientId() {
+        return clientId;
+    }
+
+    /**
+     *
+     * @param clientId
+     */
+    public void setClientId(String clientId) {
+        this.clientId = clientId;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public String getJwksUrl() {
+        return jwksUrl;
+    }
+
+    /**
+     *
+     * @param jwksUrl
+     */
+    public void setJwksUrl(String jwksUrl) {
+        this.jwksUrl = jwksUrl;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public String getAuthenticateUrl() {
+        return authenticateUrl;
+    }
+
+    /**
+     *
+     * @param authenticateUrl
+     */
+    public void setAuthenticateUrl(String authenticateUrl) {
+        this.authenticateUrl = authenticateUrl;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public boolean isSkipVerification() {
+        return skipVerification;
+    }
+
+    /**
+     *
+     * @param skipVerification
+     */
+    public void setSkipVerification(boolean skipVerification) {
+        this.skipVerification = skipVerification;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public List<String> getDeployments() {
+        return deployments;
+    }
+
+    /**
+     * 
+     * @param deployments
+     */
+    public void setDeployments(List<String> deployments) {
+        this.deployments = deployments;
+    }
+}

src/main/java/riomhaire/lti/core/model/configuration/JWKKey.java

@@ -0,0 +1,64 @@
+package riomhaire.lti.core.model.configuration;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonIgnoreProperties(ignoreUnknown = true)
+/**
+ * This represent a single names jason web key (name+public+private)
+ */
+public class JWKKey {
+    String keyId;
+    String publicKey;
+    String privateKey;
+
+    /**
+     * Get Id of key
+     * @return  id
+     */
+    public String getKeyId() {
+        return keyId;
+    }
+
+    /**
+     * set key id
+     * @param keyId the id
+     */
+    public void setKeyId(String keyId) {
+        this.keyId = keyId;
+    }
+
+    /**
+     *  Getter for public key
+     * @return   key as a string
+     */
+    public String getPublicKey() {
+        return publicKey;
+    }
+
+    /**
+     * Setter for public key
+     * @param publicKey   key as a string
+     */
+    public void setPublicKey(String publicKey) {
+        this.publicKey = publicKey;
+    }
+
+    /**
+     *  Getter for private key
+     * @return   key as a string
+     */
+    public String getPrivateKey() {
+        return privateKey;
+    }
+
+    /**
+     * Setter for private key
+     * @param privateKey   key as a string
+     */
+    public void setPrivateKey(String privateKey) {
+        this.privateKey = privateKey;
+    }
+
+}

src/main/java/riomhaire/lti/core/model/configuration/ToolConfiguration.java

@@ -0,0 +1,21 @@
+package riomhaire.lti.core.model.configuration;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+/**
+ * This class contains the model for variables need manage the tool itself - keys, secrets, urls etc
+ */
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class ToolConfiguration {
+    private JWKKey[] jwkKeys;
+
+    public JWKKey[] getJwkKeys() {
+        return jwkKeys;
+    }
+
+    public void setJwkKeys(JWKKey[] jwkKeys) {
+        this.jwkKeys = jwkKeys;
+    }
+}

src/main/java/riomhaire/lti/core/model/interfaces/ApplicationRegistry.java

@@ -1,7 +1,9 @@
 package riomhaire.lti.core.model.interfaces;
 
-import org.springframework.web.servlet.ModelAndView;
-import riomhaire.lti.core.model.LTIMessage;
+import riomhaire.lti.core.model.configuration.ClientConfiguration;
+import riomhaire.lti.core.model.configuration.ToolConfiguration;
+
+import java.util.Optional;
 
 /**
  * This is the minimal Registry info on the environment. Its the context within which commands run and can get
@@ -16,8 +18,14 @@ public interface ApplicationRegistry<R,M> {
      * And where to find the JWKS etc
      * @return     ClientRegistrationResolver
      */
-    ClientRegistrationResolver clientRegistrationResolver();
+    UniKeyResolver<Optional<ClientConfiguration>, String> clientRegistrationResolver();
 
+    /**
+     * Return the current tool configuration resolver
+     * This is where most of the tool configuration is stored -  keys, secrets etc
+     * @return     ToolConfigurationResolver
+     */
+    NoKeyResolver<Optional<ToolConfiguration>> toolConfigurationResolver();
 
     /**
      * command dispatcher... this is the entity that stores a mapping between a message type and its handler

src/main/java/riomhaire/lti/core/model/interfaces/ClientRegistrationResolver.java

@@ -1,20 +0,0 @@
-package riomhaire.lti.core.model.interfaces;
-
-import riomhaire.lti.core.model.ClientConfiguration;
-
-import java.util.Optional;
-
-/**
- *  When a tool/partner-lms is registered we need to store this information somewhere ... and we have
- *  abstracted this out as a  'ClientRegistrationResolver'. Implementations of this interface  could be
- *  to a file, DB or Redis - but all the call wants to know about is I want to find out about this deployment
- */
-public interface ClientRegistrationResolver {
-    /**
-     * Return the registration information related to this issuer/client-id pair
-     * @param issuer    ... This is canvas/blackboard or some other entity
-     * @param clientId  ... This is a particular tool within the issuer environment
-     * @return  ClientConfiguration if found
-     */
-    Optional<ClientConfiguration> lookupClient(String issuer, String clientId);
-}

src/main/java/riomhaire/lti/core/model/interfaces/NoKeyResolver.java

@@ -0,0 +1,10 @@
+package riomhaire.lti.core.model.interfaces;
+
+public interface NoKeyResolver<R> {
+        /**
+         * Return information associated with the implementor
+         *
+         * @return  object if found
+         */
+        R lookup();
+ }

src/main/java/riomhaire/lti/core/model/interfaces/UniKeyResolver.java

@@ -0,0 +1,15 @@
+package riomhaire.lti.core.model.interfaces;
+
+
+/**
+ * Generic interface of retrieve something by this key
+ */
+public interface UniKeyResolver<R,P> {
+    /**
+     * Return information associated with the key
+     * 
+     * @param key    ... This is canvas/blackboard or some other entity
+     * @return  object if found
+     */
+    R lookup(P key);
+}

src/main/resources/templates/error.html

@@ -1,12 +1,89 @@
-<!DOCTYPE HTML>
-<html>
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml"
+      xmlns:th="http://www.thymeleaf.org">
 <head>
     <meta charset="utf-8">
     <meta content="width=device-width, initial-scale=1, shrink-to-fit=yes" name="viewport">
-    <title>Opps - we have an error</title>
-</head>
+    <title>Error !!! Somethings has gone wrong</title>
+    <style>
+        table {
+            width: 100%;
+        }
+        th {
+            width: 200px;
+            text-align: right;
+            background-color: #394b58;
+            color: white;
+            font-family: Serif;
+            padding-left: 10px;
+            padding-right: 10px;
+            border-radius: 5px;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            overflow: hidden;
+            vertical-align: top;
+        }
+
+        td {
+            text-align: left;
+            background-color: #d1edfa;
+            color: #394b58;
+            font-family: Serif;
+            padding-left: 10px;
+            padding-right: 10px;
+            border-radius: 5px;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            overflow: hidden;
+        }
 
+    </style>
+
+</head>
 <body>
-Hmm
+<h1>An unexpected issue has arisen</h1>
+<table>
+    <tr>
+        <th>Date</th>
+        <td th:text="${timestamp}"/>
+    </tr>
+    <tr>
+        <th>Path</th>
+        <td th:text="${path}"/>
+    </tr>
+    <tr>
+        <th>Query Parameters</th>
+        <td>
+            <table title="Parameters">
+                <tr th:each="claim : ${queryParameters}">
+                    <th th:text="${claim.key}"></th>
+                    <td th:text="${claim.value}"/>
+                </tr>
+            </table>
+        </td>
+    </tr>
+    <tr>
+        <th>Error</th>
+        <td th:text="${error}"/>
+    </tr>
+    <tr>
+        <th>Status</th>
+        <td th:text="${status}"/>
+    </tr>
+    <tr>
+        <th>Message</th>
+        <td th:text="${message}"/>
+    </tr>
+    <tr>
+        <th>Exception</th>
+        <td th:text="${exception}"/>
+    </tr>
+    <tr>
+        <th>Trace</th>
+        <td>
+            <pre th:text="${trace}"/>
+        </td>
+    </tr>
+</table>
 </body>
 </html>