Java Code Examples for java.security.Principal

protected boolean skipProcessingByNextValves(Session session){
  Principal principal=(Principal)session.getNote(Constants.FORM_PRINCIPAL_NOTE);
  String samlRequest=(String)session.getNote(GeneralConstants.SAML_REQUEST_KEY);
  String samlResponse=(String)session.getNote(GeneralConstants.SAML_RESPONSE_KEY);
  return (principal != null && (samlRequest != null || samlResponse != null));
}
 

private void mockCert(String dn){
  X509Certificate idCert=mock(X509Certificate.class);
  Principal principal=mock(Principal.class);
  when(principal.getName()).thenReturn(dn);
  when(idCert.getSubjectDN()).thenReturn(principal);
  when(this.request.getAttribute("javax.servlet.request.X509Certificate")).thenReturn(new X509Certificate[]{idCert});
}
 

@Override public void invoke(Request request,Response response) throws IOException, ServletException {
  MessageBytes memb=request.getCoyoteRequest().getMimeHeaders().addValue("isMemberOf");
  memb.setString(this.getIsMemberOf());
  final String credentials="credentials";
  final List<String> roles=new ArrayList<String>();
  final Principal principal=new GenericPrincipal(this.getRemoteUser(),credentials,roles);
  request.setUserPrincipal(principal);
  getNext().invoke(request,response);
}
 

public boolean isUserInRole(String role){
  Principal principal=getPrincipal();
  if (principal != null) {
    return principal.getName().equals(role);
  }
  return false;
}
 

public String getLoggedInUser(){
  Principal principal=FacesContext.getCurrentInstance().getExternalContext().getUserPrincipal();
  if (principal != null) {
    return principal.getName();
  }
  return "No User";
}
 

private void initUserData(JBossEnvironment environment,HttpServletRequest request){
  Principal principal=request.getUserPrincipal();
  if (principal != null) {
    environment.setEmail(principal.getName());
  }
}
 

/** 
 * {@inheritDoc}
 */
@Override public Set<Credential> extractCredentials(WebServiceContext source){
  Set<Credential> credentials=new HashSet<Credential>();
  if (source != null) {
    Principal userPrincipal=source.getUserPrincipal();
    if (userPrincipal != null) {
      credentials.add(new PrincipalCredential(userPrincipal,true));
    }
  }
  return credentials;
}
 

/** 
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked") public boolean isMember(Principal principal){
  Enumeration en=members();
  while (en.hasMoreElements()) {
    Principal principal1=(Principal)en.nextElement();
    if (principal1.getName().equals(principal.getName()))     return true;
  }
  return false;
}
 

private String getUsername(){
  Principal p=requestGlobals.getHTTPServletRequest().getUserPrincipal();
  if (p == null) {
    return "-";
  }
  return p.getName();
}
 

public void handle(HttpExchange exchange) throws IOException {
  Principal principal=exchange.getPrincipal();
  String username=principal.getName();
  try {
    AuthManager.setCurrentUser(username);
    delegate.handle(exchange);
  }
  finally {
    AuthManager.releaseCurrentUser();
  }
}
 

@Override public ContainerRequest filter(ContainerRequest req){
  Principal principal=req.getUserPrincipal();
  if (principal != null) {
    logger.info("REQUEST from [" + principal.getName() + "] : ["+ req.getMethod()+ "]["+ req.getPath()+ "]");
  }
 else {
    logger.info("REQUEST [" + req.getMethod() + "]["+ req.getPath()+ "]");
  }
  return req;
}
 

@Override public boolean commit() throws LoginException {
  if (!subject.getPrincipals(SecurityConstants.OS_PRINCIPAL_CLASS).isEmpty()) {
    return true;
  }
  Principal user=getCanonicalUser(SecurityConstants.OS_PRINCIPAL_CLASS);
  if (user != null) {
    subject.getPrincipals().add(new UnixPrincipal(user.getName()));
    return true;
  }
  LOG.error("No such user " + subject);
  throw new LoginException("No such user " + subject);
}
 

@Override public Principal getEveryone(){
  Principal everyone=getPrincipal(EveryonePrincipal.NAME);
  if (everyone == null) {
    everyone=EveryonePrincipal.getInstance();
  }
  return everyone;
}
 

public boolean logout(final HttpServletRequest request,final HttpServletResponse response) throws AuthenticatorException {
  final HttpSession session=request.getSession();
  final Principal principal=(Principal)session.getAttribute(LOGGED_IN_KEY);
  if (LOG.isDebugEnabled()) {
    LOG.debug("Logging out [" + principal.getName() + "] from CAS.");
  }
  session.setAttribute(LOGGED_OUT_KEY,principal);
  session.setAttribute(LOGGED_IN_KEY,null);
  session.setAttribute(AbstractCasFilter.CONST_CAS_ASSERTION,null);
  return true;
}
 

private User getUser(SecurityContext context){
  Principal principal=null;
  if (context != null)   principal=context.getUserPrincipal();
  if (principal == null)   throw new WebApplicationException(Response.Status.UNAUTHORIZED);
  return getUser(principal.getName());
}
 

public SimpleUserInfo(Collection<Principal> remotingPrincipals){
  String userName=null;
  Iterator<Principal> principals=remotingPrincipals.iterator();
  while (userName == null && principals.hasNext()) {
    Principal next=principals.next();
    if (next instanceof UserPrincipal) {
      userName=((UserPrincipal)next).getName();
    }
  }
  this.userName=userName;
}
 

public String getRemoteUser(){
  String user=getPortletRequest().getRemoteUser();
  if (user == null) {
    Principal userPrincipal=getUserPrincipal();
    if (null != userPrincipal) {
      user=userPrincipal.getName();
    }
  }
  return user;
}
 

private static CallbackHandler getJBossCallbackHandler(String username,String password){
  SecurityAssociationHandler pch=new SecurityAssociationHandler();
  Principal user=getJBossPrincipal(username);
  pch.setSecurityInfo(user,password.toCharArray());
  return pch;
}
 

public void SKIPtestItPropertyFile() throws Exception {
  JAASLoginService loginService=new JAASLoginService("props");
  loginService.setLoginModuleName("props");
  LoginCallback loginCallback=new LoginCallbackImpl(new Subject(),"user","wrong".toCharArray());
  assertFalse(loginCallback.isSuccess());
  loginCallback=new LoginCallbackImpl(new Subject(),"user","user".toCharArray());
  assertTrue(loginCallback.isSuccess());
  Principal userPrincipal=loginCallback.getUserPrincipal();
  assertNotNull("principal expected",userPrincipal);
  assertEquals(userPrincipal.getName(),"user");
}
 

/** 
 * Returns a string representation of the contents of this ACL entry.
 * @return a string representation of the contents.
 */
public String toString(){
  StringBuffer sb=new StringBuffer();
  Principal p=getPrincipal();
  sb.append("[AclEntry ALLOW " + (p != null ? p.getName() : "null"));
  sb.append(" ");
  for (  Permission pp : m_permissions) {
    sb.append(pp.toString());
    sb.append(",");
  }
  sb.append("]");
  return sb.toString();
}
 

@Override public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException, ServletException {
  HttpServletRequest req=(HttpServletRequest)request;
  HttpServletResponse res=(HttpServletResponse)response;
  try {
    OAuthAccessResourceRequest oauthRequest=new OAuthAccessResourceRequest(req,parameterStyles);
    String accessToken=oauthRequest.getAccessToken();
    final OAuthDecision decision=provider.validateRequest(realm,accessToken,req);
    final Principal principal=decision.getPrincipal();
    request=new HttpServletRequestWrapper((HttpServletRequest)request){
      @Override public String getRemoteUser(){
        return principal != null ? principal.getName() : null;
      }
      @Override public Principal getUserPrincipal(){
        return principal;
      }
    }
;
    request.setAttribute(OAuth.OAUTH_CLIENT_ID,decision.getOAuthClient().getClientId());
    chain.doFilter(request,response);
    return;
  }
 catch (  OAuthSystemException e1) {
    throw new ServletException(e1);
  }
catch (  OAuthProblemException e) {
    respondWithError(res,e);
    return;
  }
}
 

public Object getUserToken(final HttpContext context){
  Principal userPrincipal=null;
  AuthState targetAuthState=(AuthState)context.getAttribute(ClientContext.TARGET_AUTH_STATE);
  if (targetAuthState != null) {
    userPrincipal=getAuthPrincipal(targetAuthState);
    if (userPrincipal == null) {
      AuthState proxyAuthState=(AuthState)context.getAttribute(ClientContext.PROXY_AUTH_STATE);
      userPrincipal=getAuthPrincipal(proxyAuthState);
    }
  }
  if (userPrincipal == null) {
    HttpRoutedConnection conn=(HttpRoutedConnection)context.getAttribute(ExecutionContext.HTTP_CONNECTION);
    if (conn.isOpen()) {
      SSLSession sslsession=conn.getSSLSession();
      if (sslsession != null) {
        userPrincipal=sslsession.getLocalPrincipal();
      }
    }
  }
  return userPrincipal;
}
 

public Principal getPrincipal(){
  return new Principal(){
    public String getName(){
      return null;
    }
  }
;
}
 

public Principal getPrincipal(){
  return new Principal(){
    public String getName(){
      return null;
    }
  }
;
}
 

public Principal getPrincipal(){
  return new Principal(){
    public String getName(){
      return null;
    }
  }
;
}
 

protected boolean doAuthentication(final Credentials credentials) throws AuthenticationException {
  final SpnegoCredentials spnegoCredentials=(SpnegoCredentials)credentials;
  Principal principal;
  byte[] nextToken;
  try {
synchronized (this) {
      this.authentication.reset();
      this.authentication.process(spnegoCredentials.getInitToken());
      principal=this.authentication.getPrincipal();
      nextToken=this.authentication.getNextToken();
    }
  }
 catch (  jcifs.spnego.AuthenticationException e) {
    throw new BadCredentialsAuthenticationException(e);
  }
  if (nextToken != null) {
    logger.debug("Setting nextToken in credentials");
    spnegoCredentials.setNextToken(nextToken);
  }
 else {
    logger.debug("nextToken is null");
  }
  if (principal != null) {
    if (spnegoCredentials.isNtlm()) {
      if (logger.isDebugEnabled()) {
        logger.debug("NTLM Credentials is valid for user [" + principal.getName() + "]");
      }
      spnegoCredentials.setPrincipal(getSimplePrincipal(principal.getName(),true));
      return this.isNTLMallowed;
    }
    if (logger.isDebugEnabled()) {
      logger.debug("Kerberos Credentials is valid for user [" + principal.getName() + "]");
    }
    spnegoCredentials.setPrincipal(getSimplePrincipal(principal.getName(),false));
    return true;
  }
  logger.debug("Principal is null, the processing of the SPNEGO Token failed");
  return false;
}
 

@Override protected void doRequest(HttpServletRequest request,HttpServletResponse response) throws IOException {
  JmxConnection connection=getConnection(request);
  if (!connection.isConnectionValid() && !_localConnection.isConnectionValid()) {
    response.sendError(503,"JMX is not enabled, unable to use cipango console. Please start Cipango with:\n" + "\tjava -jar start.jar --ini=start-cipango.ini --pre=etc/cipango-jmx.xml");
    return;
  }
  HttpSession session=request.getSession();
  Principal principal=request.getUserPrincipal();
  if (principal != null && !principal.equals(session.getAttribute(Principal.class.getName()))) {
    _logger.info("User " + principal.getName() + " has logged in console");
    session.setAttribute(Principal.class.getName(),principal);
  }
  String command=request.getServletPath();
  int index=command.lastIndexOf('/');
  if (index != -1)   command=command.substring(index + 1);
  Menu menu=getMenuFactory().getMenu(command,connection.getMbsc());
  request.setAttribute(Attributes.MENU,menu);
  Page currentPage=menu.getCurrentPage();
  if (currentPage != null && request.getAttribute(Attributes.FATAL) == null) {
    registerActions();
    Action action=getAction(currentPage,request);
    if (action != null) {
      action.process(request);
      if (action.isAjax(request)) {
        action.setAjaxContent(request,response);
      }
 else       response.sendRedirect(command);
      return;
    }
  }
  super.doRequest(request,response);
}
 

@Override public UserIdentity login(String username,Object credentials){
  if (StringUtils.equals(login,username) && StringUtils.equals(password,String.valueOf(credentials))) {
    final Credential c=new Password(String.valueOf(credentials));
    final Principal p=new KnownUser(username,c);
    final Subject subject=new Subject();
    subject.getPrincipals().add(p);
    subject.getPrivateCredentials().add(c);
    return new UserIdentity(){
      @Override public Subject getSubject(){
        return subject;
      }
      @Override public Principal getUserPrincipal(){
        return p;
      }
      @Override public boolean isUserInRole(      String role,      Scope scope){
        return true;
      }
    }
;
  }
 else {
    return null;
  }
}
 

@Override public UserIdentity login(String username,Object credentials){
  if (StringUtils.equals(login,username) && StringUtils.equals(password,String.valueOf(credentials))) {
    final Credential c=new Password(String.valueOf(credentials));
    final Principal p=new KnownUser(username,c);
    final Subject subject=new Subject();
    subject.getPrincipals().add(p);
    subject.getPrivateCredentials().add(c);
    return new UserIdentity(){
      @Override public Subject getSubject(){
        return subject;
      }
      @Override public Principal getUserPrincipal(){
        return p;
      }
      @Override public boolean isUserInRole(      String role,      Scope scope){
        return true;
      }
    }
;
  }
 else {
    return null;
  }
}
 

@Override public UserIdentity login(String username,Object credentials){
  if (StringUtils.equals(login,username) && StringUtils.equals(password,String.valueOf(credentials))) {
    final Credential c=new Password(String.valueOf(credentials));
    final Principal p=new KnownUser(username,c);
    final Subject subject=new Subject();
    subject.getPrincipals().add(p);
    subject.getPrivateCredentials().add(c);
    return new UserIdentity(){
      @Override public Subject getSubject(){
        return subject;
      }
      @Override public Principal getUserPrincipal(){
        return p;
      }
      @Override public boolean isUserInRole(      String role,      Scope scope){
        return true;
      }
    }
;
  }
 else {
    return null;
  }
}
 

public void run(){
  try {
    final String userName=session.getAttribute(SSHLifeCycle.USERNAME);
    Principal user=new Principal(){
      public String getName(){
        return userName;
      }
    }
;
    factory.handler.handle(io,user);
  }
  finally {
    callback.onExit(0);
  }
}
 

/** 
 * @return  the logged in user, or null, if they are not logged in
 */
public Principal getUser(){
  return new Principal(){
    public String getName(){
      return "maxant@maxant.co.uk";
    }
  }
;
}
 

/** 
 * @see nextapp.echo2.app.ApplicationInstance#init()
 */
public Window init(){
  if (InteractiveApp.LIVE_DEMO_SERVER) {
    throw new RuntimeException("Authentication test disabled on live demo server.");
  }
  Window mainWindow=new Window();
  mainWindow.setTitle("NextApp Echo2 Authentication Test Application");
  ContentPane content=new ContentPane();
  mainWindow.setContent(content);
  Column mainColumn=new Column();
  mainColumn.setBorder(new Border(new Extent(4),Color.BLUE,Border.STYLE_OUTSET));
  mainColumn.setInsets(new Insets(40));
  mainColumn.setCellSpacing(new Extent(20));
  content.add(mainColumn);
  ContainerContext containerContext=(ContainerContext)getContextProperty(ContainerContext.CONTEXT_PROPERTY_NAME);
  Principal principal=containerContext.getUserPrincipal();
  mainColumn.add(new Label("getUserPrincipal(): " + (principal == null ? "null" : principal.getName())));
  mainColumn.add(new Label("isUserInRole(\"role1\"): " + containerContext.isUserInRole("role1")));
  return mainWindow;
}
 

/** 
 * Apply a principal-based security check for entities that were resolved from the backing store. This code will follow one or more property paths for the entity and resolve the object at the end of the path into one or more principals. The test passes if the current principal is in the list. Otherwise, a warning is added to the context.
 */
public boolean checkAccess(HasUuid object){
  if (!wasResolved(object)) {
    return true;
  }
  if (getRoles().isEmpty()) {
    return true;
  }
  Principal principal=getPrincipal();
  if (!principalMapper.isAccessEnforced(principal,object)) {
    return true;
  }
  List<PropertyPath> paths=typeContext.getPrincipalPaths(object.getClass());
  PropertyPathChecker checker=checkers.get();
  for (  PropertyPath path : paths) {
    path.evaluate(object,checker);
    if (checker.getResult()) {
      return true;
    }
  }
  addWarning(object,"User %s does not have permission to edit this %s",principal,typeContext.getPayloadName(object.getClass()));
  return false;
}
 

/** 
 * Sets the slf4j <code>MDC</code> and delegates the request to the chain.
 * @param request servlet request.
 * @param response servlet response.
 * @param chain filter chain.
 * @throws IOException thrown if an IO error occurrs.
 * @throws ServletException thrown if a servet error occurrs.
 */
@Override public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain) throws IOException, ServletException {
  try {
    MDC.clear();
    String hostname=HostnameFilter.get();
    if (hostname != null) {
      MDC.put("hostname",HostnameFilter.get());
    }
    Principal principal=((HttpServletRequest)request).getUserPrincipal();
    String user=(principal != null) ? principal.getName() : null;
    if (user != null) {
      MDC.put("user",user);
    }
    MDC.put("method",((HttpServletRequest)request).getMethod());
    MDC.put("path",((HttpServletRequest)request).getPathInfo());
    chain.doFilter(request,response);
  }
  finally {
    MDC.clear();
  }
}
 

public Object getUserToken(final HttpContext context){
  Principal userPrincipal=null;
  AuthState targetAuthState=(AuthState)context.getAttribute(ClientContext.TARGET_AUTH_STATE);
  if (targetAuthState != null) {
    userPrincipal=getAuthPrincipal(targetAuthState);
    if (userPrincipal == null) {
      AuthState proxyAuthState=(AuthState)context.getAttribute(ClientContext.PROXY_AUTH_STATE);
      userPrincipal=getAuthPrincipal(proxyAuthState);
    }
  }
  if (userPrincipal == null) {
    HttpConnection conn=(HttpConnection)context.getAttribute(ExecutionContext.HTTP_CONNECTION);
    if (conn instanceof HttpSSLConnection) {
      SSLSession sslsession=((HttpSSLConnection)conn).getSSLSession();
      if (sslsession != null) {
        userPrincipal=sslsession.getLocalPrincipal();
      }
    }
  }
  return userPrincipal;
}
 

/** 
 * <p> This test requests a SAMLV1.1 assertion on behalf of another identity. The STS must issue an assertion for the identity contained in the  {@code OnBehalfOf} section of the WS-Trust request (and not for the identity that sentthe request). </p>
 * @throws Exception if an error occurs while running the test.
 */
@Test public void testIssueSAML11OnBehalfOf() throws Exception {
  Element assertionElement=client.issueTokenOnBehalfOf(null,SAMLUtil.SAML11_TOKEN_TYPE,new Principal(){
    @Override public String getName(){
      return "jduke";
    }
  }
);
  Assert.assertNotNull("Invalid null assertion element",assertionElement);
  SAML11AssertionType assertion=this.validateSAML11Assertion(assertionElement,"jduke",SAMLUtil.SAML11_SENDER_VOUCHES_URI);
  SAML11ConditionsType conditions=assertion.getConditions();
  Assert.assertEquals("Unexpected restriction list size",0,conditions.get().size());
}
 

@Override public String doProcess(ResolverContext context) throws ProcessorException {
  if (context.isPost()) {
    HttpServletRequest req=context.getRequest();
    String mail=req.getParameter("m");
    String text=req.getParameter("text");
    if (StringUtils.isEmpty(mail) || StringUtils.isEmpty(text)) {
      Flash.error(req,MessageResource.getMessage("fields_required"));
      return null;
    }
    if (!Validator.isValidEmail(mail)) {
      Flash.error(req,MessageResource.getMessage("invalid_email"));
      return null;
    }
    IDDBService app=(IDDBService)context.getServletContext().getAttribute("jipdbs");
    if (!app.isRecaptchaValid(req.getRemoteAddr(),req.getParameter("recaptcha_challenge_field"),req.getParameter("recaptcha_response_field"))) {
      Flash.error(req,MessageResource.getMessage("invalid_captcha"));
      return null;
    }
    Principal user=req.getUserPrincipal();
    app.sendAdminMail(user != null ? user.getName() : null,mail,text);
    Flash.ok(req,MessageResource.getMessage("mail_sent"));
  }
  return null;
}
 

public Authorizer(final User user){
  this.principal=new Principal(){
    public String getName(){
      return user.getFoafId().toString();
    }
  }
;
}
 

public void doFilter(ServletRequest servletRequest,ServletResponse servletResponse,FilterChain filterChain) throws IOException, ServletException {
  String actorId=null;
  if (servletRequest instanceof HttpServletRequest) {
    HttpServletRequest httpServletRequest=(HttpServletRequest)servletRequest;
    Principal userPrincipal=httpServletRequest.getUserPrincipal();
    if (userPrincipal != null) {
      actorId=userPrincipal.getName();
    }
  }
  if (actorId == null) {
    Authentication auth=Hudson.getAuthentication();
    if (auth != null) {
      actorId=auth.getName();
    }
  }
  JbpmContext jbpmContext=getJbpmConfiguration().createJbpmContext(jbpmContextName);
  try {
    if (isAuthenticationEnabled) {
      jbpmContext.setActorId(actorId);
    }
    filterChain.doFilter(servletRequest,servletResponse);
  }
  finally {
    jbpmContext.close();
  }
}
 

public Principal getUserPrincipal(){
  Principal userPrincipal;
  Object scPrincipal=getSubjectPrincipal();
  if (scPrincipal != null) {
    if (scPrincipal instanceof Principal) {
      userPrincipal=(Principal)scPrincipal;
    }
 else {
      userPrincipal=new ObjectPrincipal(scPrincipal);
    }
  }
 else {
    userPrincipal=super.getUserPrincipal();
  }
  return userPrincipal;
}
 

public Principal getUserPrincipal(){
  return principalName == null ? null : new Principal(){
    public String getName(){
      return principalName;
    }
  }
;
}
 

/** 
 * Initializes the authentication handler instance. <p/> It creates a Kerberos context using the principal and keytab specified in the configuration. <p/> This method is invoked by the  {@link AuthenticationFilter#init} method.
 * @param config configuration properties to initialize the handler.
 * @throws ServletException thrown if the handler could not be initialized.
 */
@Override public void init(Properties config) throws ServletException {
  try {
    principal=config.getProperty(PRINCIPAL,principal);
    if (principal == null || principal.trim().length() == 0) {
      throw new ServletException("Principal not defined in configuration");
    }
    keytab=config.getProperty(KEYTAB,keytab);
    if (keytab == null || keytab.trim().length() == 0) {
      throw new ServletException("Keytab not defined in configuration");
    }
    if (!new File(keytab).exists()) {
      throw new ServletException("Keytab does not exist: " + keytab);
    }
    Set<Principal> principals=new HashSet<Principal>();
    principals.add(new KerberosPrincipal(principal));
    Subject subject=new Subject(false,principals,new HashSet<Object>(),new HashSet<Object>());
    KerberosConfiguration kerberosConfiguration=new KerberosConfiguration(keytab,principal);
    loginContext=new LoginContext("",subject,null,kerberosConfiguration);
    loginContext.login();
    Subject serverSubject=loginContext.getSubject();
    try {
      gssManager=Subject.doAs(serverSubject,new PrivilegedExceptionAction<GSSManager>(){
        @Override public GSSManager run() throws Exception {
          return GSSManager.getInstance();
        }
      }
);
    }
 catch (    PrivilegedActionException ex) {
      throw ex.getException();
    }
    LOG.info("Initialized, principal [{}] from keytab [{}]",principal,keytab);
  }
 catch (  Exception ex) {
    throw new ServletException(ex);
  }
}
 

/** 
 * Creates a  {@code PrivateCredentialPermission} from the {@code Credential}class and set of principals.
 * @param credentialClass the credential class name.
 * @param principals the set of principals.
 */
PrivateCredentialPermission(String credentialClass,Set<Principal> principals){
  super(credentialClass);
  this.credentialClass=credentialClass;
  set=new CredOwner[principals.size()];
  for (  Principal p : principals) {
    CredOwner element=new CredOwner(p.getClass().getName(),p.getName());
    boolean found=false;
    for (int ii=0; ii < offset; ii++) {
      if (set[ii].equals(element)) {
        found=true;
        break;
      }
    }
    if (!found) {
      set[offset++]=element;
    }
  }
}
 

/** 
 * Creates a  {@code PrivateCredentialPermission} from the {@code Credential}class and set of principals.
 * @param credentialClass the credential class name.
 * @param principals the set of principals.
 */
PrivateCredentialPermission(String credentialClass,Set<Principal> principals){
  super(credentialClass);
  this.credentialClass=credentialClass;
  set=new CredOwner[principals.size()];
  for (  Principal p : principals) {
    CredOwner element=new CredOwner(p.getClass().getName(),p.getName());
    boolean found=false;
    for (int ii=0; ii < offset; ii++) {
      if (set[ii].equals(element)) {
        found=true;
        break;
      }
    }
    if (!found) {
      set[offset++]=element;
    }
  }
}
 

/** 
 * <p> We check the credentials against the repository. By convention, the username is the repository name and the password is either the publisher or subscriber password. The role assigned to the user is constructed from the combination of username and publisher password. </p>
 * @return Returns true if this method succeeded, or false if this LoginModule should be ignored.
 */
public boolean login() throws LoginException {
  try {
    Iterator<Principal> iterator=_subject.getPrincipals().iterator();
    String username=iterator.next().getName();
    if (StringUtils.isBlank(username)) {
      throw new FailedLoginException("Username is requried.");
    }
    Iterator<char[]> iterator2=_subject.getPrivateCredentials(char[].class).iterator();
    char[] passwordChars=iterator2.next();
    String password=new String(passwordChars);
    if (StringUtils.isBlank(password)) {
      throw new FailedLoginException("Password is requried.");
    }
    if (username.equals(_systemUsername) && password.equals(_systemPassword)) {
      Group roles=new SimpleGroup("Roles");
      roles.addMember(new SimplePrincipal(UserBO.SYSTEM_ADMINISTRATOR_ROLE_NAME));
      _subject.getPrincipals().add(roles);
      return true;
    }
    DB db=MongoConnection.getInstance().getConnection();
    UserBO user=UserController.getInstance().tryGetByUsername(db,username);
    if (user == null) {
      throw new FailedLoginException("Invalid username or password.");
    }
    if (StringUtils.isBlank(password) || !user.validatePassword(password)) {
      throw new FailedLoginException("Invalid username or password.");
    }
    Group roles=new SimpleGroup("Roles");
    for (    String role : user.getRoles()) {
      roles.addMember(new SimplePrincipal(role));
    }
    _subject.getPrincipals().add(roles);
    return true;
  }
 catch (  Exception ex) {
    throw new LoginException(ex.getMessage());
  }
}
 

public Principal getUserPrincipal(){
  if (user != null) {
    return user;
  }
 else {
    return prePrincipal;
  }
}
 

/** 
 * @see nextapp.echo.webcontainer.ContainerContext#getUserPrincipal()
 */
public Principal getUserPrincipal(){
  Connection conn=WebContainerServlet.getActiveConnection();
  if (conn == null) {
    return null;
  }
 else {
    return conn.getRequest().getUserPrincipal();
  }
}
 

public static void main(String[] args) throws Exception {
  System.setProperty("java.security.auth.login.config","login.conf");
  System.setProperty("java.security.krb5.conf","krb5.conf");
  System.setProperty("sun.security.krb5.debug","true");
  System.setProperty("javax.security.auth.useSubjectCredsOnly","false");
  DefaultHttpClient httpclient=new DefaultHttpClient();
  try {
    NegotiateSchemeFactory nsf=new NegotiateSchemeFactory();
    httpclient.getAuthSchemes().register(AuthPolicy.SPNEGO,nsf);
    Credentials use_jaas_creds=new Credentials(){
      public String getPassword(){
        return null;
      }
      public Principal getUserPrincipal(){
        return null;
      }
    }
;
    httpclient.getCredentialsProvider().setCredentials(new AuthScope(null,-1,null),use_jaas_creds);
    HttpUriRequest request=new HttpGet("http://kerberoshost/");
    HttpResponse response=httpclient.execute(request);
    HttpEntity entity=response.getEntity();
    System.out.println("----------------------------------------");
    System.out.println(response.getStatusLine());
    System.out.println("----------------------------------------");
    if (entity != null) {
      System.out.println(EntityUtils.toString(entity));
    }
    System.out.println("----------------------------------------");
    EntityUtils.consume(entity);
  }
  finally {
    httpclient.getConnectionManager().shutdown();
  }
}
 

/** 
 * Simple scenario for updating one composite object
 */
@Transactional @RequestMapping(value=HOME_PAGE,method=RequestMethod.GET) public String home(Principal currentUser,Model model){
  model.addAttribute("connectionsToProviders",getConnectionRepository().findAllConnections());
  if (currentUser != null) {
    model.addAttribute("account",accountRepository.findOne(currentUser.getName()));
  }
  logger.info("Welcome home!");
  MyCounter counter=counterRepo.findOne(HOME_PAGE);
  if (counter == null) {
    counter=new MyCounter(HOME_PAGE);
  }
  counter.count++;
  counterRepo.save(counter);
  model.addAttribute("count",counter.count);
  return "home";
}
 

public static void main(String[] args) throws Exception {
  System.setProperty("java.security.auth.login.config","login.conf");
  System.setProperty("java.security.krb5.conf","krb5.conf");
  System.setProperty("sun.security.krb5.debug","true");
  System.setProperty("javax.security.auth.useSubjectCredsOnly","false");
  DefaultHttpClient httpclient=new DefaultHttpClient();
  try {
    NegotiateSchemeFactory nsf=new NegotiateSchemeFactory();
    httpclient.getAuthSchemes().register(AuthPolicy.SPNEGO,nsf);
    Credentials use_jaas_creds=new Credentials(){
      public String getPassword(){
        return null;
      }
      public Principal getUserPrincipal(){
        return null;
      }
    }
;
    httpclient.getCredentialsProvider().setCredentials(new AuthScope(null,-1,null),use_jaas_creds);
    HttpUriRequest request=new HttpGet("http://kerberoshost/");
    HttpResponse response=httpclient.execute(request);
    HttpEntity entity=response.getEntity();
    System.out.println("----------------------------------------");
    System.out.println(response.getStatusLine());
    System.out.println("----------------------------------------");
    if (entity != null) {
      System.out.println(EntityUtils.toString(entity));
    }
    System.out.println("----------------------------------------");
    EntityUtils.consume(entity);
  }
  finally {
    httpclient.getConnectionManager().shutdown();
  }
}
 

@Override public AuthorizingCallbackHandler getCallbackHandler(String mechanismName){
  if (mechanismName.equals(ANONYMOUS)) {
    return new AuthorizingCallbackHandler(){
      public void handle(      Callback[] callbacks) throws IOException, UnsupportedCallbackException {
        for (        Callback current : callbacks) {
          throw new UnsupportedCallbackException(current,"ANONYMOUS mechanism so not expecting a callback");
        }
      }
      @Override public UserInfo createUserInfo(      Collection<Principal> remotingPrincipals) throws IOException {
        if (remotingPrincipals == null) {
          return null;
        }
        return new SimpleUserInfo(remotingPrincipals);
      }
    }
;
  }
  return null;
}
 

public boolean equals(Object another){
  if (!(another instanceof Principal)) {
    return false;
  }
  String anotherName=((Principal)another).getName();
  if (this.name == null) {
    return (this.name == anotherName);
  }
 else {
    return this.name.equals(anotherName);
  }
}