test/jdk/javax/security/auth/login/LoginContext/LCTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 import com.sun.security.auth.UnixPrincipal;

 import javax.security.auth.Subject;
 import javax.security.auth.callback.*;
 import javax.security.auth.login.FailedLoginException;
 import javax.security.auth.login.LoginContext;
 import javax.security.auth.login.LoginException;
 import javax.security.auth.spi.LoginModule;
 import java.io.IOException;
 import java.security.Principal;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;

 /*
  * @test
  * @bug 8050460
  * @summary Test checks that proper methods associated with login/logout process
  * of LoginContext are called for different configurations and circumstances.
  * @modules jdk.security.auth
  *
  * @run main/othervm  LCTest EmptyModuleConfig false
  * @run main/othervm  LCTest IncorrectName false
  * @run main/othervm  LCTest AbortRequisite false abort
  * @run main/othervm  LCTest AbortSufficient false abort
  * @run main/othervm  LCTest AbortRequired false abort
  * @run main/othervm  LCTest LogoutRequisite false logout
  * @run main/othervm  LCTest LogoutSufficient true logout
  * @run main/othervm  LCTest LogoutRequired false logout
  * @run main/othervm  LCTest LoginRequisite false login
  * @run main/othervm  LCTest LoginSufficient true login
  * @run main/othervm  LCTest LoginRequired false login
  */

 public class LCTest {

     private static final String USER_NAME = "testUser";
     private static final String PASSWORD = "testPassword";
     private static final List<String> loggedActions = new ArrayList<>();

     static {
         System.setProperty("java.security.auth.login.config",
                 System.getProperty("test.src")
                         + System.getProperty("file.separator")
                         + "LCTest.jaas.config");
     }

     public static void main(String[] args) {
         if (args.length < 2) {
             throw new RuntimeException("Incorrect test params");
         }
         String nameOfContext = args[0];
         boolean isPositive = Boolean.parseBoolean(args[1]);
         String actionName = null;
         if (args.length == 3) {
             actionName = args[2];
         }
         try {
             LoginContext lc = new LoginContext(nameOfContext,
                     new MyCallbackHandler());
             lc.login();
             checkPrincipal(lc, true);
             lc.logout();
             checkPrincipal(lc, false);
             if (!isPositive) {
                 throw new RuntimeException("Test failed. Exception expected.");
             }
         } catch (LoginException le) {
             if (isPositive) {
                 throw new RuntimeException("Test failed. Unexpected " +
                         "exception", le);
             }
             System.out.println("Expected exception: "
                     + le.getMessage());
         }
         checkActions(actionName);
         System.out.println("Test passed.");
     }

     /*
      * Log action from login modules
      */
     private static void logAction(String actionName) {
         loggedActions.add(actionName);
     }

     /*
      * Check if logged actions are as expected. We always expected 3 actions
      * if any.
      */
     private static void checkActions(String actionName) {
         if (actionName == null) {
             if (loggedActions.size() != 0) {
                 throw new RuntimeException("No logged actions expected");
             }
         } else {
             int loggedActionsFound = 0;
             System.out.println("Logged actions : " + loggedActions);
             for (String s : loggedActions) {
                 if (s.equals(actionName)) {
                     loggedActionsFound++;
                 }
             }
             if (loggedActionsFound != 3) {
                 throw new RuntimeException("Incorrect number of actions " +
                         actionName + " : " + loggedActionsFound);
             }
         }
     }

     /*
      * Check context for principal of the test user.
      */
     private static void checkPrincipal(LoginContext loginContext, boolean
             principalShouldExist) {
         if (!principalShouldExist) {
             if (loginContext.getSubject().getPrincipals().size() != 0) {
                 throw new RuntimeException("Test failed. Principal was not " +
                         "cleared.");
             }
         } else {
             for (Principal p : loginContext.getSubject().getPrincipals()) {
                 if (p instanceof UnixPrincipal &&
                         USER_NAME.equals(p.getName())) {
                     //Proper principal was found, return.
                     return;
                 }
             }
             throw new RuntimeException("Test failed. UnixPrincipal "
                     + USER_NAME + " expected.");
         }
     }

     private static class MyCallbackHandler implements CallbackHandler {

         @Override
         public void handle(Callback[] callbacks) throws IOException,
                 UnsupportedCallbackException {
             for (Callback callback : callbacks) {
                 if (callback instanceof NameCallback) {
                     ((NameCallback) callback).setName(USER_NAME);
                 } else if (callback instanceof PasswordCallback) {
                     ((PasswordCallback) callback).setPassword(
                             PASSWORD.toCharArray());
                 } else {
                     throw new UnsupportedCallbackException(callback);
                 }
             }
         }
     }

     /* -------------------------------------------------------------------------
      * Test login modules
      * -------------------------------------------------------------------------
      */

     /*
      * Login module that should pass through all phases.
      */
     public static class LoginModuleAllPass extends LoginModuleBase {

     }

     /*
      * Login module that throws Exception in abort method.
      */
     public static class LoginModuleWithAbortException extends LoginModuleBase {

         @Override
         public boolean abort() throws LoginException {
             super.abort();
             throw new LoginException("Abort failed!");
         }
     }

     /*
      * Login module that throws Exception in login method.
      */
     public static class LoginModuleWithLoginException extends LoginModuleBase {

         @Override
         public boolean login() throws LoginException {
             super.login();
             throw new FailedLoginException("Login failed!");
         }
     }

     /*
      * Login module that throws Exception in logout method.
      */
     public static class LoginModuleWithLogoutException extends LoginModuleBase {

         @Override
         public boolean logout() throws LoginException {
             super.logout();
             throw new FailedLoginException("Logout failed!");
         }
     }

     /*
      * Base class for login modules
      */
     public static abstract class LoginModuleBase implements LoginModule {
         // initial state
         private Subject subject;
         private CallbackHandler callbackHandler;
         private Map sharedState;
         private Map options;
         private UnixPrincipal userPrincipal;

         // username and password
         private String username;
         private String password;

         // the authentication status
         private boolean succeeded = false;
         private boolean commitSucceeded = false;

         @Override
         public void initialize(Subject subject, CallbackHandler callbackHandler,
                                Map<String, ?> sharedState, Map<String, ?> options) {

             this.subject = subject;
             this.callbackHandler = callbackHandler;
             this.sharedState = sharedState;
             this.options = options;
             System.out.println("Login module initialized.");
         }

         /*
          * Authenticate the user by prompting for a username and password.
          */
         @Override
         public boolean login() throws LoginException {
             LCTest.logAction("login");
             if (callbackHandler == null) {
                 throw new LoginException("No CallbackHandler available");
             }

             Callback[] callbacks = new Callback[2];
             callbacks[0] = new NameCallback("Username: ");
             callbacks[1] = new PasswordCallback("Password: ", false);

             try {
                 callbackHandler.handle(callbacks);
                 username = ((NameCallback) callbacks[0]).getName();
                 password = new String(((PasswordCallback) callbacks[1])
                         .getPassword());
                 if (username.equals(LCTest.USER_NAME) &&
                         password.equals(LCTest.PASSWORD)) {
                     succeeded = true;
                     return true;
                 }
                 throw new FailedLoginException("Incorrect username/password!");
             } catch (IOException | UnsupportedCallbackException e) {
                 throw new LoginException("Login failed: " + e.getMessage());
             }
         }

         @Override
         public boolean commit() throws LoginException {
             LCTest.logAction("commit");
             if (succeeded == false) {
                 return false;
             }
             userPrincipal = new UnixPrincipal(username);
             final Subject s = subject;
             final UnixPrincipal up = userPrincipal;
             java.security.AccessController.doPrivileged
                     ((java.security.PrivilegedAction) () -> {
                         if (!s.getPrincipals().contains(up)) {
                             s.getPrincipals().add(up);
                         }
                         return null;
                     });
             password = null;
             commitSucceeded = true;
             return true;
         }

         @Override
         public boolean abort() throws LoginException {
             LCTest.logAction("abort");
             if (succeeded == false) {
                 return false;
             }
             clearState();
             return true;
         }

         @Override
         public boolean logout() throws LoginException {
             LCTest.logAction("logout");
             clearState();
             return true;
         }

         private void clearState() {
             if (commitSucceeded) {
                 final Subject s = subject;
                 final UnixPrincipal up = userPrincipal;
                 java.security.AccessController.doPrivileged
                         ((java.security.PrivilegedAction) () -> {
                             s.getPrincipals().remove(up);
                             return null;
                         });
             }
             username = null;
             password = null;
             userPrincipal = null;
         }
     }

 }
	/*
	* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	import com.sun.security.auth.UnixPrincipal;

	import javax.security.auth.Subject;
	import javax.security.auth.callback.*;
	import javax.security.auth.login.FailedLoginException;
	import javax.security.auth.login.LoginContext;
	import javax.security.auth.login.LoginException;
	import javax.security.auth.spi.LoginModule;
	import java.io.IOException;
	import java.security.Principal;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Map;

	/*
	* @test
	* @bug 8050460
	* @summary Test checks that proper methods associated with login/logout process
	* of LoginContext are called for different configurations and circumstances.
	* @modules jdk.security.auth
	*
	* @run main/othervm LCTest EmptyModuleConfig false
	* @run main/othervm LCTest IncorrectName false
	* @run main/othervm LCTest AbortRequisite false abort
	* @run main/othervm LCTest AbortSufficient false abort
	* @run main/othervm LCTest AbortRequired false abort
	* @run main/othervm LCTest LogoutRequisite false logout
	* @run main/othervm LCTest LogoutSufficient true logout
	* @run main/othervm LCTest LogoutRequired false logout
	* @run main/othervm LCTest LoginRequisite false login
	* @run main/othervm LCTest LoginSufficient true login
	* @run main/othervm LCTest LoginRequired false login
	*/

	public class LCTest {

	private static final String USER_NAME = "testUser";
	private static final String PASSWORD = "testPassword";
	private static final List<String> loggedActions = new ArrayList<>();

	static {
	System.setProperty("java.security.auth.login.config",
	System.getProperty("test.src")
	+ System.getProperty("file.separator")
	+ "LCTest.jaas.config");
	}

	public static void main(String[] args) {
	if (args.length < 2) {
	throw new RuntimeException("Incorrect test params");
	}
	String nameOfContext = args[0];
	boolean isPositive = Boolean.parseBoolean(args[1]);
	String actionName = null;
	if (args.length == 3) {
	actionName = args[2];
	}
	try {
	LoginContext lc = new LoginContext(nameOfContext,
	new MyCallbackHandler());
	lc.login();
	checkPrincipal(lc, true);
	lc.logout();
	checkPrincipal(lc, false);
	if (!isPositive) {
	throw new RuntimeException("Test failed. Exception expected.");
	}
	} catch (LoginException le) {
	if (isPositive) {
	throw new RuntimeException("Test failed. Unexpected " +
	"exception", le);
	}
	System.out.println("Expected exception: "
	+ le.getMessage());
	}
	checkActions(actionName);
	System.out.println("Test passed.");
	}

	/*
	* Log action from login modules
	*/
	private static void logAction(String actionName) {
	loggedActions.add(actionName);
	}

	/*
	* Check if logged actions are as expected. We always expected 3 actions
	* if any.
	*/
	private static void checkActions(String actionName) {
	if (actionName == null) {
	if (loggedActions.size() != 0) {
	throw new RuntimeException("No logged actions expected");
	}
	} else {
	int loggedActionsFound = 0;
	System.out.println("Logged actions : " + loggedActions);
	for (String s : loggedActions) {
	if (s.equals(actionName)) {
	loggedActionsFound++;
	}
	}
	if (loggedActionsFound != 3) {
	throw new RuntimeException("Incorrect number of actions " +
	actionName + " : " + loggedActionsFound);
	}
	}
	}

	/*
	* Check context for principal of the test user.
	*/
	private static void checkPrincipal(LoginContext loginContext, boolean
	principalShouldExist) {
	if (!principalShouldExist) {
	if (loginContext.getSubject().getPrincipals().size() != 0) {
	throw new RuntimeException("Test failed. Principal was not " +
	"cleared.");
	}
	} else {
	for (Principal p : loginContext.getSubject().getPrincipals()) {
	if (p instanceof UnixPrincipal &&
	USER_NAME.equals(p.getName())) {
	//Proper principal was found, return.
	return;
	}
	}
	throw new RuntimeException("Test failed. UnixPrincipal "
	+ USER_NAME + " expected.");
	}
	}

	private static class MyCallbackHandler implements CallbackHandler {

	@Override
	public void handle(Callback[] callbacks) throws IOException,
	UnsupportedCallbackException {
	for (Callback callback : callbacks) {
	if (callback instanceof NameCallback) {
	((NameCallback) callback).setName(USER_NAME);
	} else if (callback instanceof PasswordCallback) {
	((PasswordCallback) callback).setPassword(
	PASSWORD.toCharArray());
	} else {
	throw new UnsupportedCallbackException(callback);
	}
	}
	}
	}

	/* -------------------------------------------------------------------------
	* Test login modules
	* -------------------------------------------------------------------------
	*/

	/*
	* Login module that should pass through all phases.
	*/
	public static class LoginModuleAllPass extends LoginModuleBase {

	}

	/*
	* Login module that throws Exception in abort method.
	*/
	public static class LoginModuleWithAbortException extends LoginModuleBase {

	@Override
	public boolean abort() throws LoginException {
	super.abort();
	throw new LoginException("Abort failed!");
	}
	}

	/*
	* Login module that throws Exception in login method.
	*/
	public static class LoginModuleWithLoginException extends LoginModuleBase {

	@Override
	public boolean login() throws LoginException {
	super.login();
	throw new FailedLoginException("Login failed!");
	}
	}

	/*
	* Login module that throws Exception in logout method.
	*/
	public static class LoginModuleWithLogoutException extends LoginModuleBase {

	@Override
	public boolean logout() throws LoginException {
	super.logout();
	throw new FailedLoginException("Logout failed!");
	}
	}

	/*
	* Base class for login modules
	*/
	public static abstract class LoginModuleBase implements LoginModule {
	// initial state
	private Subject subject;
	private CallbackHandler callbackHandler;
	private Map sharedState;
	private Map options;
	private UnixPrincipal userPrincipal;

	// username and password
	private String username;
	private String password;

	// the authentication status
	private boolean succeeded = false;
	private boolean commitSucceeded = false;

	@Override
	public void initialize(Subject subject, CallbackHandler callbackHandler,
	Map<String, ?> sharedState, Map<String, ?> options) {

	this.subject = subject;
	this.callbackHandler = callbackHandler;
	this.sharedState = sharedState;
	this.options = options;
	System.out.println("Login module initialized.");
	}

	/*
	* Authenticate the user by prompting for a username and password.
	*/
	@Override
	public boolean login() throws LoginException {
	LCTest.logAction("login");
	if (callbackHandler == null) {
	throw new LoginException("No CallbackHandler available");
	}

	Callback[] callbacks = new Callback[2];
	callbacks[0] = new NameCallback("Username: ");
	callbacks[1] = new PasswordCallback("Password: ", false);

	try {
	callbackHandler.handle(callbacks);
	username = ((NameCallback) callbacks[0]).getName();
	password = new String(((PasswordCallback) callbacks[1])
	.getPassword());
	if (username.equals(LCTest.USER_NAME) &&
	password.equals(LCTest.PASSWORD)) {
	succeeded = true;
	return true;
	}
	throw new FailedLoginException("Incorrect username/password!");
	} catch (IOException \| UnsupportedCallbackException e) {
	throw new LoginException("Login failed: " + e.getMessage());
	}
	}

	@Override
	public boolean commit() throws LoginException {
	LCTest.logAction("commit");
	if (succeeded == false) {
	return false;
	}
	userPrincipal = new UnixPrincipal(username);
	final Subject s = subject;
	final UnixPrincipal up = userPrincipal;
	java.security.AccessController.doPrivileged
	((java.security.PrivilegedAction) () -> {
	if (!s.getPrincipals().contains(up)) {
	s.getPrincipals().add(up);
	}
	return null;
	});
	password = null;
	commitSucceeded = true;
	return true;
	}

	@Override
	public boolean abort() throws LoginException {
	LCTest.logAction("abort");
	if (succeeded == false) {
	return false;
	}
	clearState();
	return true;
	}

	@Override
	public boolean logout() throws LoginException {
	LCTest.logAction("logout");
	clearState();
	return true;
	}

	private void clearState() {
	if (commitSucceeded) {
	final Subject s = subject;
	final UnixPrincipal up = userPrincipal;
	java.security.AccessController.doPrivileged
	((java.security.PrivilegedAction) () -> {
	s.getPrincipals().remove(up);
	return null;
	});
	}
	username = null;
	password = null;
	userPrincipal = null;
	}
	}

	}