import org.jivesoftware.openfire.auth.InternalUnauthenticatedException; //导入依赖的package包/类
/**
 * Sets a new password for this user.
 *
 * @param password the new password for the user.
 * @throws UnsupportedOperationException exception
 */
public void setPassword(String password) throws UnsupportedOperationException {
    if (UserManager.getUserProvider().isReadOnly()) {
        throw new UnsupportedOperationException("User provider is read-only.");
    }

    try {
        AuthFactory.setPassword(username, password);

        // Fire event.
        Map<String,Object> params = new HashMap<>();
        params.put("type", "passwordModified");
        UserEventDispatcher.dispatchEvent(this, UserEventDispatcher.EventType.user_modified,
                params);
    }
    catch (UserNotFoundException | ConnectionException | InternalUnauthenticatedException e) {
        Log.error(e.getMessage(), e);
    }
}
 

import org.jivesoftware.openfire.auth.InternalUnauthenticatedException; //导入依赖的package包/类
public void authenticate(String userName, String password) throws UnauthorizedException, ConnectionException, InternalUnauthenticatedException {
	if (auditPlugin == null) {
		auditPlugin = (AuditPlugin)(XMPPServer.getInstance().getPluginManager().getPlugin(JiveProperties.getInstance().get(AUDIT_PLUGIN_PROPERTY_NAME)));
	}

       boolean doAudit = false;
       if (auditPlugin == null && !hasWarnedNoAuditing) {
           System.out.println("SuperuserAuthProvider.authenticate() Warning: audit plugin not found.");

           hasWarnedNoAuditing = true;
       } else {
           doAudit = JiveProperties.getInstance().getBooleanProperty("com.surevine.chat.openfire.auth.logSuperuserLogins");
       }

       if (!password.equals(JiveProperties.getInstance().get(PASSWORD_PROPERTY))) {
   		if (doAudit) {
               auditPlugin.getAuditMessageFactory().createAuditMessageForSULogin(userName, false);
           }

   		throw new UnauthorizedException("The super user provided an incorrect password");
   	}

       if (doAudit) {
   		auditPlugin.getAuditMessageFactory().createAuditMessageForSULogin(userName, true);
       }
}
 

import org.jivesoftware.openfire.auth.InternalUnauthenticatedException; //导入依赖的package包/类
/**
 * Returns if the username and password are valid; otherwise this
 * method throws an UnauthorizedException.<p>
 *
 * @param username the username or full JID.
 * @param password the password
 * @throws UnauthorizedException if the username and password do
 *      not match any existing user.
 * @throws ConnectionException it there is a problem connecting to user and group sytem
 * @throws InternalUnauthenticatedException if there is a problem authentication Openfire itself into the user and group system
 */
@Override
public void authenticate(String username, String password) throws UnauthorizedException, ConnectionException, InternalUnauthenticatedException {
    if (manager == null) {
        throw new ConnectionException("Unable to connect to Crowd");
    }

    if (username == null || password == null || "".equals(password.trim())) {
        throw new UnauthorizedException();
    }

    if (username.contains("@")) {
        // Check that the specified domain matches the server's domain
        int index = username.indexOf("@");
        String domain = username.substring(index + 1);
        if (domain.equals(XMPPServer.getInstance().getServerInfo().getXMPPDomain())) {
            username = username.substring(0, index);
        } else {
            // Unknown domain. Return authentication failed.
            throw new UnauthorizedException();
        }
    }

    try {
        manager.authenticate(username, password);
    } catch (RemoteException re) {
        throw new UnauthorizedException();
    }
}
 

import org.jivesoftware.openfire.auth.InternalUnauthenticatedException; //导入依赖的package包/类
/**
 * Authenticates a user with a username, token, and digest and returns an AuthToken.
 * The digest should be generated using the {@link AuthFactory#createDigest(String, String)} method.
 * If the username and digest do not match the record of any user in the system, the
 * method throws an UnauthorizedException.
 *
 * @param username the username.
 * @param token the token that was used with plain-text password to generate the digest.
 * @param digest the digest generated from plain-text password and unique token.
 * @return an AuthToken token if the username and digest are correct for the user's
 *      password and given token.
 * @throws UnauthorizedException if the username and password do not match any
 *      existing user or the account is locked out.
 */
public static AuthToken authenticate(String username, String token, String digest)
        throws UnauthorizedException, ConnectionException, InternalUnauthenticatedException {
    if (username == null || token == null || digest == null) {
        throw new UnauthorizedException();
    }
    if ( LockOutManager.getInstance().isAccountDisabled(username)) {
        LockOutManager.getInstance().recordFailedLogin(username);
        throw new UnauthorizedException();
    }
    username = username.trim().toLowerCase();
    if (username.contains("@")) {
        // Check that the specified domain matches the server's domain
        int index = username.indexOf("@");
        String domain = username.substring(index + 1);
        if (domain.equals( XMPPServer.getInstance().getServerInfo().getXMPPDomain())) {
            username = username.substring(0, index);
        } else {
            // Unknown domain. Return authentication failed.
            throw new UnauthorizedException();
        }
    }
    try {
        String password = AuthFactory.getPassword( username );
        String anticipatedDigest = AuthFactory.createDigest(token, password);
        if (!digest.equalsIgnoreCase(anticipatedDigest)) {
            throw new UnauthorizedException();
        }
    }
    catch (UserNotFoundException unfe) {
        throw new UnauthorizedException();
    }
    // Got this far, so the user must be authorized.
    return new AuthToken(username);
}
 

import org.jivesoftware.openfire.auth.InternalUnauthenticatedException; //导入依赖的package包/类
/**
    * Returns if the username and password are valid; otherwise this
    * method throws an UnauthorizedException.<p>
    *
    * If {@link #isPlainSupported()} returns false, this method should
    * throw an UnsupportedOperationException.
    *
    * @param username the username or full JID.
    * @param password the password
    * @throws UnauthorizedException if the username and password do
    *      not match any existing user.
    * @throws ConnectionException it there is a problem connecting to user and group sytem
    * @throws InternalUnauthenticatedException if there is a problem authentication Openfire itself into the user and group system
    */
public void authenticate(String username, String password) throws UnauthorizedException, ConnectionException, InternalUnauthenticatedException {
	if (manager == null) {
		throw new ConnectionException("Unable to connect to Crowd");
	}

       if (username == null || password == null || "".equals(password.trim())) {
           throw new UnauthorizedException();
       }

       if (username.contains("@")) {
           // Check that the specified domain matches the server's domain
           int index = username.indexOf("@");
           String domain = username.substring(index + 1);
           if (domain.equals(XMPPServer.getInstance().getServerInfo().getXMPPDomain())) {
               username = username.substring(0, index);
           } else {
               // Unknown domain. Return authentication failed.
               throw new UnauthorizedException();
           }
       }

       try {
		manager.authenticate(username, password);
	} catch (RemoteException re) {
		throw new UnauthorizedException();
	}
}
 

import org.jivesoftware.openfire.auth.InternalUnauthenticatedException; //导入依赖的package包/类
@Test(expected = UnauthorizedException.class)
public void testAuthenticateStringStringFailure()
		throws UnauthorizedException, ConnectionException,
		InternalUnauthenticatedException {
	authProvider.authenticate(AUTH_FAILURE_USERNAME, AUTH_FAILURE_PASSWORD);
}
 

import org.jivesoftware.openfire.auth.InternalUnauthenticatedException; //导入依赖的package包/类
/**
 * Returns if the username and password are valid; otherwise this method
 * throws an <code>UnauthorizedException</code>.
 * <p>
 * <p/>
 * If {@link #isPlainSupported()} returns false, this method should throw an
 * <code>UnsupportedOperationException</code>.
 * 
 * @param username
 *            The username or full JID.
 * @param password
 *            The password.
 * @throws org.jivesoftware.openfire.auth.UnauthorizedException
 *             If the username and password do not match any existing user.
 * @throws org.jivesoftware.openfire.auth.ConnectionException
 *             If Openfire is not able to connect to the user and group
 *             system.
 * @throws org.jivesoftware.openfire.auth.InternalUnauthenticatedException
 *             If Openfire is not able to authenticate itself into the user
 *             and group system.
 */
public void authenticate(final String username, final String password)
		throws UnauthorizedException, ConnectionException,
		InternalUnauthenticatedException {
	if (ticketValidator == null) {
		throw new ConnectionException();
	}

	// Connect to CAS and validate the proxy ticket.
	// The password field contains the CAS proxy ticket.
	ticketValidator.authenticateCASProxyTicket(username, password);
}