import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
public static JSONObject doExecuteJSONRequest(RemoteConnectorRequest request, RemoteConnectorService service) throws ParseException, IOException, AuthenticationException
{
    // Set as JSON
    request.setContentType(MimetypeMap.MIMETYPE_JSON);
    
    // Perform the request
    RemoteConnectorResponse response = service.executeRequest(request);
    
    // Parse this as JSON
    JSONParser parser = new JSONParser();
    String jsonText = response.getResponseBodyAsString();
    Object json = parser.parse(jsonText);
    
    // Check it's the right type and return
    if (json instanceof JSONObject)
    {
        return (JSONObject)json;
    }
    else
    {
        throw new ParseException(0, json);
    }
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
/**
 * The login method.
 * 
 */
public boolean test(String userid, String password)
{
    try
    {
        authenticationService.authenticate(userid, password.toCharArray());
        String email = null;
        if (personService.personExists(userid))
        {
            NodeRef personNodeRef = personService.getPerson(userid);
            email = (String) nodeService.getProperty(personNodeRef, ContentModel.PROP_EMAIL);
        }
        GreenMailUser user = new AlfrescoImapUser(email, userid, password);
        addUser(user);
    }
    catch (AuthenticationException ex)
    {
        logger.error("IMAP authentication failed for userid: " + userid);
        return false;
    }
    return true;
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
@Override
public void enableTenant(String tenantDomain)
{ 
    tenantDomain = getTenantDomain(tenantDomain);
    
    if (! existsTenant(tenantDomain))
    {
        throw new AuthenticationException("Tenant does not exist: " + tenantDomain);
    }
    
    if (isEnabledTenant(tenantDomain))
    {
        logger.warn("Tenant already enabled: " + tenantDomain);
    }
    
    TenantUpdateEntity tenantUpdateEntity = tenantAdminDAO.getTenantForUpdate(tenantDomain);
    tenantUpdateEntity.setEnabled(true);
    tenantAdminDAO.updateTenant(tenantUpdateEntity);
    
    notifyAfterEnableTenant(tenantDomain);
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
@Override
public void disableTenant(String tenantDomain)
{ 
    tenantDomain = getTenantDomain(tenantDomain);
    
    if (! existsTenant(tenantDomain))
    {
        throw new AuthenticationException("Tenant does not exist: " + tenantDomain);
    }
    
    if (! isEnabledTenant(tenantDomain))
    {
        logger.warn("Tenant already disabled: " + tenantDomain);
    }
    
    notifyBeforeDisableTenant(tenantDomain);
    
    // update tenant attributes / tenant cache - need to disable after notifying listeners (else they cannot disable) 
    TenantUpdateEntity tenantUpdateEntity = tenantAdminDAO.getTenantForUpdate(tenantDomain);
    tenantUpdateEntity.setEnabled(false);
    tenantAdminDAO.updateTenant(tenantUpdateEntity);
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
/**
 * Checks if a user ticket is still valid
 * 
 * @return {@link Boolean} value: <code>true</code> if the ticket is still valid, <code>false</code> if the ticket is not valid any more
 */
private boolean isTicketValid()
{
    try
    {
        authenticationService.validate(ticket);
        return true;
    }
    catch (AuthenticationException e)
    {
        if (logger.isDebugEnabled())
        {
            logger.debug("User ticket is not valid. Passing to the Basic authentication handling. Reqeust information:\n"
                    + "    ticket: " + ticket + "\n"
                    + "    request: " + servletReq.getQueryString() + "\n"
                    + "    error: " + e, e);
        }

        return false;
    }
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
protected Map<String, Object> login(final String username, String password)
{
    try
    {
        // get ticket
        authenticationService.authenticate(username, password.toCharArray());

        eventPublisher.publishEvent(new EventPreparator(){
            @Override
            public Event prepareEvent(String user, String networkId, String transactionId)
            {
            	// TODO need to fix up to pass correct seqNo and alfrescoClientId
                return new RepositoryEventImpl(-1l, "login", transactionId, networkId, new Date().getTime(),
                		username, null);
            }
        });
        
        // add ticket to model for javascript and template access
        Map<String, Object> model = new HashMap<String, Object>(7, 1.0f);
        model.put("username", username);
        model.put("ticket",  authenticationService.getCurrentTicket());
        
        return model;
    }
    catch(AuthenticationException e)
    {
        throw new WebScriptException(HttpServletResponse.SC_FORBIDDEN, "Login failed");
    }
    finally
    {
        AuthenticationUtil.clearCurrentSecurityContext();
    }
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
@Override
public LoginTicketResponse createTicket(LoginTicket loginRequest, Parameters parameters)
{
    validateLoginRequest(loginRequest);
    try
    {
        // get ticket
        authenticationService.authenticate(loginRequest.getUserId(), loginRequest.getPassword().toCharArray());

        LoginTicketResponse response = new LoginTicketResponse();
        response.setUserId(loginRequest.getUserId());
        response.setId(authenticationService.getCurrentTicket());

        return response;
    }
    catch (AuthenticationException e)
    {
        throw new PermissionDeniedException("Login failed");
    }
    finally
    {
        AuthenticationUtil.clearCurrentSecurityContext();
    }
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
/**
 * Perform a failed login attempt
 */
private void loginWithFailure(final String username) throws Exception
{
    // Force a failed login
    RunAsWork<Void> failureWork = new RunAsWork<Void>()
    {
        @Override
        public Void doWork() throws Exception
        {
            try
            {
                authenticationService.authenticate(username, "crud".toCharArray());
                fail("Failed to force authentication failure");
            }
            catch (AuthenticationException e)
            {
                // Expected
            }
            return null;
        }
    };
    AuthenticationUtil.runAs(failureWork, AuthenticationUtil.getSystemUserName());
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
public NodeRef addUserDescription(final String personId, final TestNetwork network, final String personDescription)
{
	return AuthenticationUtil.runAsSystem(new RunAsWork<NodeRef>()
	{
		//@Override
		public NodeRef doWork() throws Exception
		{
			NodeRef userRef = personService.getPersonOrNull(personId);
			if (userRef == null)
			{
				throw new AuthenticationException("User name does not exist: " + personId);
			}

			ContentWriter writer = contentService.getWriter(userRef, ContentModel.PROP_PERSONDESC, true);
			writer.setMimetype(MimetypeMap.MIMETYPE_HTML);
			writer.putContent(personDescription);

			log("Updated person description " + personId + (network != null ? " in network " + network : ""));
			return userRef;
		}
	});
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
/**
 * Perform a login attempt (to be used to create audit entries)
 */
private void login(final String username, final String password) throws Exception 
{
    // Force a failed login
    RunAsWork<Void> failureWork = new RunAsWork<Void>() 
    {
        @Override
        public Void doWork() throws Exception 
        {
            try 
            {
                authenticationService.authenticate(username, password.toCharArray());
                fail("Failed to force authentication failure");
            } 
            catch (AuthenticationException e) 
            {
                // Expected
            }
            return null;
        }
    };
    AuthenticationUtil.runAs(failureWork, AuthenticationUtil.getSystemUserName());
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected void authenticateImpl(final String userName, final char[] password) throws AuthenticationException
{
    String baseUserName;

    final Pair<String, String> userTenant = AuthenticationUtil.getUserTenant(userName);
    final String tenantDomain = userTenant.getSecond();
    if (this.stripTenantDomainForAuthentication && EqualsHelper.nullSafeEquals(this.tenantDomain, tenantDomain))
    {
        baseUserName = this.tenantService.getBaseNameUser(userName);
    }
    else
    {
        baseUserName = userName;
    }

    super.authenticateImpl(baseUserName, password);
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
@Override
public Authentication setCurrentUser(final String authenticatedUserName) throws AuthenticationException
{
    String domainUser = authenticatedUserName;
    if (!EqualsHelper.nullSafeEquals(this.tenantDomain, TenantUtil.DEFAULT_TENANT))
    {
        TenantContextHolder.setTenantDomain(this.tenantDomain);

        final String domain = this.tenantService.getDomain(authenticatedUserName);
        if (!EqualsHelper.nullSafeEquals(domain, this.tenantDomain))
        {
            domainUser = this.tenantService.getDomainUser(authenticatedUserName, this.tenantDomain);
        }
    }

    final Authentication authentication = super.setCurrentUser(domainUser);
    return authentication;
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
/**
 * Get home space for current user
 * 
 * @return String url to home space
 */
public String getUserHomeLocation()
{
    NodeRef currentUser = personService.getPerson(authenticationComponent.getCurrentUserName());
    
    if (currentUser == null)
    {
        throw new AuthenticationException("No user have been authorized.");
    }
    
    NodeRef homeSpace = (NodeRef) nodeService.getProperty(currentUser, ContentModel.PROP_HOMEFOLDER);
    
    if (homeSpace == null)
    {
        throw new RuntimeException("No home space was found.");
    }
    
    return toUrlPath(fileFolderService.getFileInfo(homeSpace));        
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
private String normalizeUserId(String externalUserId) throws SMBSrvException
{
    try
    {
        return mapUserNameToPerson(externalUserId, true);
    }
    catch (AuthenticationException e)
    {
        // Invalid user. Return a logon failure status
        logger.debug("Authentication Exception", e);
        throw new SMBSrvException(SMBStatus.NTLogonFailure, SMBStatus.ErrDos, SMBStatus.DOSAccessDenied);
    }
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
/**
 * authenticate with a user/password
 * @param userName
 * @param password
 * @return true - authenticated
 */
protected boolean authenticateUserNamePassword(String userName, char[] password)
{
    try
    {
        getAuthenticationComponent().authenticate(userName, password);
        return true;
    }
    catch (AuthenticationException e)
    {
        return false;
    }
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
@Override
public InitialDirContext getInitialDirContext(String principal,
        String credentials)
        throws AuthenticationException
{
    return getInitialDirContext(principal, credentials, null);
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
private void invalidateTasksByUser(String userName) throws AuthenticationException
{
    List<Invitation> listForInvitee = listPendingInvitationsForInvitee(userName);
    for (Invitation inv : listForInvitee)
    {
        cancel(inv.getInviteId());
    }
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
@Override
public Tenant getTenant(String tenantDomain)
{
    tenantDomain = getTenantDomain(tenantDomain);
    if (! existsTenant(tenantDomain))
    {
        throw new AuthenticationException("Tenant does not exist: " + tenantDomain);
    }
    
    return getTenantAttributes(tenantDomain);
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
public Object invoke(MethodInvocation mi) throws Throwable 
{
    while (true)
    {
        try
        {
            MethodInvocation clone = ((ReflectiveMethodInvocation)mi).invocableClone();
            return clone.proceed();
        }
        catch (AuthenticationException ae)
        {
            // Sleep for an interval and try again.
            try
            {
                Thread.sleep(fRetryInterval);
            }
            catch (InterruptedException ie)
            {
                // Do nothing.
            }
            try
            {
                // Reauthenticate.
                fAuthService.authenticate(fUser, fPassword.toCharArray());
                String ticket = fAuthService.getCurrentTicket();
                fTicketHolder.setTicket(ticket);
                // Modify the ticket argument.
                mi.getArguments()[0] = ticket;
            }
            catch (Exception e)
            {
                // Do nothing.
            }
        }
    }
}
 

import org.alfresco.repo.security.authentication.AuthenticationException; //导入依赖的package包/类
/**
 * Returns the current Alfresco Ticket for the current user on
 *  the remote system, fetching if it isn't already cached.
 */
public RemoteAlfrescoTicketInfo getAlfrescoTicket(String remoteSystemId)
   throws AuthenticationException, NoCredentialsFoundException, NoSuchSystemException, RemoteSystemUnavailableException
{
    // Check we know about the system
    ensureRemoteSystemKnown(remoteSystemId);
    
    // Grab the user's details
    BaseCredentialsInfo creds = getRemoteCredentials(remoteSystemId);
    PasswordCredentialsInfo credentials = ensureCredentialsFound(remoteSystemId, creds);
    
    // Is there a cached ticket?
    String cacheKey = toCacheKey(remoteSystemId, credentials);
    String ticket = ticketsCache.get(cacheKey);
    
    // Refresh if if isn't cached
    if (ticket == null)
    {
        return refreshTicket(remoteSystemId, credentials);
    }
    else
    {
        if (logger.isDebugEnabled())
            logger.debug("Cached ticket found for " + creds.getRemoteUsername() + " on " + remoteSystemId);
            
        // Wrap and return
        return new AlfTicketRemoteAlfrescoTicketImpl(ticket);
    }
}