javax.security.auth.spi.LoginModule Java Examples

@SuppressWarnings("unchecked")
private static Class<LoginModule> getLoginModuleClass() {
    Class<?> clz = null;
    try {
        // try the jetty9 version
        clz = Class.forName("org.eclipse.jetty.jaas.spi.PropertyFileLoginModule",
                                       true, BookLoginModule.class.getClassLoader());
    } catch (Throwable t) {
        if (clz == null) {
            try {
                // try the jetty8 version
                clz = Class.forName("org.eclipse.jetty.plus.jaas.spi.PropertyFileLoginModule",
                                               true, BookLoginModule.class.getClassLoader());
            } catch (Throwable t2) {
                // ignore
            }
        }
    }
    return (Class<LoginModule>)clz;
}
 

@BuildStep
void contributeClassesToIndex(BuildProducer<AdditionalIndexedClassesBuildItem> additionalIndexedClasses,
        BuildProducer<IndexDependencyBuildItem> indexDependency) {
    // This is needed for SASL authentication

    additionalIndexedClasses.produce(new AdditionalIndexedClassesBuildItem(
            LoginModule.class.getName(),
            javax.security.auth.Subject.class.getName(),
            javax.security.auth.login.AppConfigurationEntry.class.getName(),
            javax.security.auth.login.AppConfigurationEntry.LoginModuleControlFlag.class.getName()));

    indexDependency.produce(new IndexDependencyBuildItem("org.apache.kafka", "kafka-clients"));
}
 

@BuildStep
public void withSasl(BuildProducer<ReflectiveClassBuildItem> reflectiveClass,
        BuildProducer<ReflectiveHierarchyBuildItem> reflectiveHierarchy) {

    reflectiveClass.produce(new ReflectiveClassBuildItem(false, false, AbstractLogin.DefaultLoginCallbackHandler.class));
    reflectiveClass.produce(new ReflectiveClassBuildItem(false, false, SaslClientCallbackHandler.class));
    reflectiveClass.produce(new ReflectiveClassBuildItem(false, false, DefaultLogin.class));

    final Type loginModuleType = Type
            .create(DotName.createSimple(LoginModule.class.getName()), Kind.CLASS);

    reflectiveHierarchy.produce(new ReflectiveHierarchyBuildItem(loginModuleType));
}
 

public void initialize(Subject subject, CallbackHandler callbackHandler,
        Map<String,?> sharedState, Map<String,?> options)
  {
      log = Logger.getLogger(getClass());
      
      /* TODO: this module should really extend AbstractServerLoginModule where the options check is integrated.
	     * the code here has been intentionally kept identical
	     */
	    HashSet<String> validOptions = new HashSet<String>(Arrays.asList(ALL_VALID_OPTIONS));
      for (Object key : options.keySet())
      {
    	 if (!validOptions.contains(key))
         {
            PicketBoxLogger.LOGGER.warnInvalidModuleOption((String) key);
         }
      }

moduleName = (String) options.get(MODULE_NAME);
      if( moduleName == null )
      {
          return;
      }

      // Load the delegate module using the thread class loader
      ClassLoader loader = SecurityActions.getContextClassLoader();
      try
      {
          Class<?> clazz = loader.loadClass(moduleName);
          delegate = (LoginModule) clazz.newInstance();
      }
      catch(Throwable t)
      {
          t.printStackTrace();
          return;
      }

      delegate.initialize(subject, callbackHandler, sharedState, options);
  }
 

/**
 * This method delegates to a login module if configured in the module options.
 * The sub classes will need to validate the request 
 */
public AuthStatus validateRequest(MessageInfo messageInfo, Subject clientSubject, 
      Subject serviceSubject) 
throws AuthException
{
   String loginModuleName = (String) options.get("login-module-delegate");
   if(loginModuleName != null)
   {
      ClassLoader tcl = SecurityActions.getContextClassLoader();
      try
      {
         Class clazz = tcl.loadClass(loginModuleName);
         LoginModule lm = (LoginModule) clazz.newInstance();
         lm.initialize(clientSubject, callbackHandler, new HashMap(), options);
         lm.login();
         lm.commit();
      }
      catch (Exception e)
      {
         throw new AuthException(e.getLocalizedMessage());
      }
   } 
   else
   {
      return validate(clientSubject, messageInfo) ? AuthStatus.SUCCESS : AuthStatus.FAILURE;
   } 
   
   return AuthStatus.SUCCESS;
}
 

@Override
public void initialize(Subject subject, CallbackHandler callbackHandler, Map<String, ?> sharedState,
                       Map<String, ?> options) {
    BundleContext context = (BundleContext) options.get(BundleContext.class.getName());
    if (context == null) {
        throw new IllegalStateException("Option " + BundleContext.class.getName()
                + " must be set to the BundleContext of the module");
    }
    String module = (String) options.get(MODULE);
    if (module == null) {
        throw new IllegalStateException("Option " + MODULE + " must be set to the name of the module");
    }
    String bundleId = (String) options.get(BUNDLE_ID);
    if (bundleId == null) {
        throw new IllegalStateException("Option " + BUNDLE_ID
                + " must be set to the name of the bundle with the module");
    }
    Bundle bundle = context.getBundle(Long.parseLong(bundleId));
    if (bundle == null) {
        throw new IllegalStateException("No bundle found for id " + bundleId);
    }
    try {
        target = (LoginModule) bundle.loadClass(module).newInstance();
    } catch (Exception e) {
        throw new IllegalStateException("Can not load or create login module " + module
                + " for bundle " + bundleId, e);
    }
    target.initialize(subject, callbackHandler, sharedState, options);
}
 

@Test
public void testCommitOnFailedLogin() throws LoginException {
   LoginModule loginModule = new LDAPLoginModule();
   JaasCallbackHandler callbackHandler = new JaasCallbackHandler(null, null, null);

   loginModule.initialize(new Subject(), callbackHandler, null, new HashMap<String, Object>());

   // login should return false due to null username
   assertFalse(loginModule.login());

   // since login failed commit should return false as well
   assertFalse(loginModule.commit());
}
 

ModuleInfo(AppConfigurationEntry newEntry, LoginModule newModule) {
    this.entry = newEntry;
    this.module = newModule;
}
 

ModuleInfo(AppConfigurationEntry newEntry, LoginModule newModule) {
    this.entry = newEntry;
    this.module = newModule;
}