This class authenticates a Subject and then
* executes a specified application as that Subject.
* To use this class, the java interpreter would typically be invoked as:
*
*
* % java -Djava.security.manager \ * Login \ ** **
applicationClass represents the application to be executed
* as the authenticated Subject,
* and applicationClass_args are passed as arguments to
* applicationClass.
*
*
To perform the authentication, Login uses a
* LoginContext. A LoginContext relies on a
* Configuration to determine the modules that should be used
* to perform the actual authentication. The location of the Configuration
* is dependent upon each Configuration implementation.
* The default Configuration implementation
* (com.sun.security.auth.login.ConfigFile)
* allows the Configuration location to be specified (among other ways)
* via the java.security.auth.login.config system property.
* Therefore, the Login class can also be invoked as:
*
*
* % java -Djava.security.manager \ * -Djava.security.auth.login.config=*/ public class Login { /** *\ * Login \ * *
Instantate a LoginContext using the
* provided application classname as the index for the login
* Configuration. Authenticate the Subject
* (three retries are allowed) and invoke
* Subject.doAsPrivileged
* with the authenticated Subject and a
* PrivilegedExceptionAction.
* The PrivilegedExceptionAction
* loads the provided application class, and then invokes
* its public static main method, passing it
* the application arguments.
*
*
*
* @param args the arguments for Login. The first
* argument must be the class name of the application to be
* invoked once authentication has completed, and the
* subsequent arguments are the arguments to be passed
* to that application's public static main method.
*/
public static void main(String[] args) {
// check for the application's main class
if (args == null || args.length == 0) {
System.err.println("Invalid arguments: " +
"Did not provide name of application class.");
System.exit(-1);
}
LoginContext lc = null;
try {
lc = new LoginContext(args[0], new TextCallbackHandler());
} catch (LoginException le) {
System.err.println("Cannot create LoginContext. "
+ le.getMessage());
System.exit(-1);
} catch (SecurityException se) {
System.err .println("Cannot create LoginContext. "
+ se.getMessage());
System.exit(-1);
}
// the user has 3 attempts to authenticate successfully
int i;
for (i = 0; i < 3; i++) {
try {
// attempt authentication
lc.login();
// if we return with no exception, authentication succeeded
break;
} catch (AccountExpiredException aee) {
System.err.println("Your account has expired. " +
"Please notify your administrator.");
System.exit(-1);
} catch (CredentialExpiredException cee) {
System.err.println("Your credentials have expired.");
System.exit(-1);
} catch (FailedLoginException fle) {
System.err.println("Authentication Failed");
try {
Thread.currentThread().sleep(3000);
} catch (Exception e) {
// ignore
}
} catch (Exception e) {
System.err.println("Unexpected Exception - unable to continue");
e.printStackTrace();
System.exit(-1);
}
}
// did they fail three times?
if (i == 3) {
System.err.println("Sorry");
System.exit(-1);
}
// push the subject into the current ACC
try {
Subject.doAsPrivileged(lc.getSubject(),
new MyAction(args),
null);
} catch (java.security.PrivilegedActionException pae) {
pae.printStackTrace();
System.exit(-1);
}
System.exit(0);
}
}
class MyAction implements java.security.PrivilegedExceptionAction {
String[] origArgs;
public MyAction(String[] origArgs) {
this.origArgs = (String[])origArgs.clone();
}
public Object run() throws Exception {
// get the ContextClassLoader
ClassLoader cl = Thread.currentThread().getContextClassLoader();
try {
// get the application class's main method
Class c = Class.forName(origArgs[0], true, cl);
Class[] PARAMS = { origArgs.getClass() };
java.lang.reflect.Method mainMethod = c.getMethod("main", PARAMS);
// invoke the main method with the remaining args
String[] appArgs = new String[origArgs.length - 1];
System.arraycopy(origArgs, 1, appArgs, 0, origArgs.length - 1);
Object[] args = { appArgs };
mainMethod.invoke(null /*ignored*/, args);
} catch (Exception e) {
throw new java.security.PrivilegedActionException(e);
}
// successful completion
return null;
}
}