Java AuthFactory.createDigest方法代码示例

import org.jivesoftware.openfire.auth.AuthFactory; //导入方法依赖的package包/类
/**
 * Authenticates the connection manager. Shared secret is validated with the one provided
 * by the connection manager. If everything went fine then the session will have a status
 * of "authenticated" and the connection manager will receive the client configuration
 * options.
 *
 * @param digest the digest provided by the connection manager with the handshake stanza.
 * @return true if the connection manager was sucessfully authenticated.
 */
public boolean authenticate(String digest) {
    // Perform authentication. Wait for the handshake (with the secret key)
    String anticipatedDigest = AuthFactory.createDigest(getStreamID().getID(),
            ConnectionMultiplexerManager.getDefaultSecret());
    // Check that the provided handshake (secret key + sessionID) is correct
    if (!anticipatedDigest.equalsIgnoreCase(digest)) {
        Log.debug("LocalConnectionMultiplexerSession: [ConMng] Incorrect handshake for connection manager with domain: " +
                getAddress().getDomain());
        //  The credentials supplied by the initiator are not valid (answer an error
        // and close the connection)
        conn.deliverRawText(new StreamError(StreamError.Condition.not_authorized).toXML());
        // Close the underlying connection
        conn.close();
        return false;
    }
    else {
        // Component has authenticated fine
        setStatus(STATUS_AUTHENTICATED);
        // Send empty handshake element to acknowledge success
        conn.deliverRawText("<handshake></handshake>");
        Log.debug("LocalConnectionMultiplexerSession: [ConMng] Connection manager was AUTHENTICATED with domain: " + getAddress());
        sendClientOptions();
        return true;
    }
}
 

import org.jivesoftware.openfire.auth.AuthFactory; //导入方法依赖的package包/类
/**
 * Verifies the key sent by a Receiving Server. This server will be acting as the
 * Authoritative Server when executing this method. The remote server may have established
 * a new connection to the Authoritative Server (i.e. this server) for verifying the key
 * or it may be reusing an existing incoming connection.
 *
 * @param doc the Element that contains the key to verify.
 * @param connection the connection to use for sending the verification result
 * @return true if the key was verified.
 */
public static boolean verifyReceivedKey(Element doc, Connection connection) {
    String verifyFROM = doc.attributeValue("from");
    String verifyTO = doc.attributeValue("to");
    String key = doc.getTextTrim();
    StreamID streamID = BasicStreamIDFactory.createStreamID( doc.attributeValue("id") );

    final Logger log = LoggerFactory.getLogger( Log.getName() + "[Acting as Authoritative Server: Verify key sent by RS: " + verifyFROM + " (id " + streamID+ ")]" );

    log.debug( "Verifying key... ");

    // TODO If the value of the 'to' address does not match a recognized hostname,
    // then generate a <host-unknown/> stream error condition
    // TODO If the value of the 'from' address does not match the hostname
    // represented by the Receiving Server when opening the TCP connection, then
    // generate an <invalid-from/> stream error condition

    // Verify the received key
    // Created the expected key based on the received ID value and the shared secret
    String expectedKey = AuthFactory.createDigest(streamID.getID(), getSecretkey());
    boolean verified = expectedKey.equals(key);

    // Send the result of the key verification
    StringBuilder sb = new StringBuilder();
    sb.append("<db:verify");
    sb.append(" from=\"").append(verifyTO).append("\"");
    sb.append(" to=\"").append(verifyFROM).append("\"");
    sb.append(" type=\"");
    sb.append(verified ? "valid" : "invalid");
    sb.append("\" id=\"").append(streamID.getID()).append("\"/>");
    connection.deliverRawText(sb.toString());
    log.debug("Verification successful! Key was: " + (verified ? "VALID" : "INVALID"));
    return verified;
}
 

import org.jivesoftware.openfire.auth.AuthFactory; //导入方法依赖的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.AuthFactory; //导入方法依赖的package包/类
/**
 * Verifies the key sent by a Receiving Server. This server will be acting as the
 * Authoritative Server when executing this method. The remote server may have established
 * a new connection to the Authoritative Server (i.e. this server) for verifying the key
 * or it may be reusing an existing incoming connection.
 *
 * @param doc the Element that contains the key to verify.
 * @param connection the connection to use for sending the verification result
 * @return true if the key was verified.
 */
public static boolean verifyReceivedKey(Element doc, Connection connection) {
    String verifyFROM = doc.attributeValue("from");
    String verifyTO = doc.attributeValue("to");
    String key = doc.getTextTrim();
    String id = doc.attributeValue("id");
    Log.debug("ServerDialback: AS - Verifying key for host: " + verifyFROM + " id: " + id);

    // TODO If the value of the 'to' address does not match a recognized hostname,
    // then generate a <host-unknown/> stream error condition
    // TODO If the value of the 'from' address does not match the hostname
    // represented by the Receiving Server when opening the TCP connection, then
    // generate an <invalid-from/> stream error condition

    // Verify the received key
    // Created the expected key based on the received ID value and the shared secret
    String expectedKey = AuthFactory.createDigest(id, getSecretkey());
    boolean verified = expectedKey.equals(key);

    // Send the result of the key verification
    StringBuilder sb = new StringBuilder();
    sb.append("<db:verify");
    sb.append(" from=\"").append(verifyTO).append("\"");
    sb.append(" to=\"").append(verifyFROM).append("\"");
    sb.append(" type=\"");
    sb.append(verified ? "valid" : "invalid");
    sb.append("\" id=\"").append(id).append("\"/>");
    connection.deliverRawText(sb.toString());
    Log.debug("ServerDialback: AS - Key was: " + (verified ? "VALID" : "INVALID") + " for host: " +
            verifyFROM +
            " id: " +
            id);
    return verified;
}
 

import org.jivesoftware.openfire.auth.AuthFactory; //导入方法依赖的package包/类
/**
 * Authenticate the external component using a digest method. The digest includes the
 * stream ID and the secret key of the main domain of the external component. A component
 * needs to authenticate just once but it may bind several domains.
 *
 * @param digest the digest sent in the handshake.
 * @return true if the authentication was successful.
 */
public boolean authenticate(String digest) {
    // Perform authentication. Wait for the handshake (with the secret key)
    String secretKey = ExternalComponentManager.getSecretForComponent(defaultSubdomain);
    String anticipatedDigest = AuthFactory.createDigest(getStreamID().getID(), secretKey);
    // Check that the provided handshake (secret key + sessionID) is correct
    if (!anticipatedDigest.equalsIgnoreCase(digest)) {
        Log.debug("LocalComponentSession: [ExComp] Incorrect handshake for component with domain: " +
                defaultSubdomain);
        //  The credentials supplied by the initiator are not valid (answer an error
        // and close the connection)
        conn.deliverRawText(new StreamError(StreamError.Condition.not_authorized).toXML());
        // Close the underlying connection
        conn.close();
        return false;
    }
    else {
        // Component has authenticated fine
        setStatus(STATUS_AUTHENTICATED);
        // Send empty handshake element to acknowledge success
        conn.deliverRawText("<handshake></handshake>");
        // Bind the domain to this component
        ExternalComponent component = getExternalComponent();
        try {
            InternalComponentManager.getInstance().addComponent(defaultSubdomain, component);
            Log.debug(
                    "LocalComponentSession: [ExComp] External component was registered SUCCESSFULLY with domain: " +
                            defaultSubdomain);
            return true;
        }
        catch (ComponentException e) {
            Log.debug("LocalComponentSession: [ExComp] Another component is already using domain: " +
                    defaultSubdomain);
            //  The credentials supplied by the initiator are not valid (answer an error
            // and close the connection)
            conn.deliverRawText(new StreamError(StreamError.Condition.conflict).toXML());
            // Close the underlying connection
            conn.close();
            return false;
        }
    }
}
 

import org.jivesoftware.openfire.auth.AuthFactory; //导入方法依赖的package包/类
/**
 * Authenticates the Originating Server domain with the Receiving Server. Once the domain has
 * been authenticated the Receiving Server will start accepting packets from the Originating
 * Server.<p>
 *
 * The Receiving Server will connect to the Authoritative Server to verify the dialback key.
 * Most probably the Originating Server machine will be the Authoritative Server too.
 *
 * @param socketReader the reader to use for reading the answer from the Receiving Server.
 * @param localDomain the domain to authenticate.
 * @param remoteDomain the domain of the remote server (i.e. Receiving Server).
 * @param id the stream id to be used for creating the dialback key.
 * @return true if the Receiving Server authenticated the domain with the Authoritative Server.
 */
public boolean authenticateDomain(OutgoingServerSocketReader socketReader, String localDomain, String remoteDomain, String id) {

    final Logger log = LoggerFactory.getLogger( Log.getName() + "[Acting as Originating Server: Authenticate domain: " + localDomain + " with RS: " + remoteDomain + " (id: " + id + ")]" );

    log.debug( "Authenticating domain ..." );

    String key = AuthFactory.createDigest( id, getSecretkey() );

    synchronized (socketReader) {
        log.debug( "Sending dialback key and wait for the validation response..." );
        StringBuilder sb = new StringBuilder();
        sb.append("<db:result");
        sb.append(" from=\"").append(localDomain).append("\"");
        sb.append(" to=\"").append(remoteDomain).append("\">");
        sb.append(key);
        sb.append("</db:result>");
        connection.deliverRawText(sb.toString());

        // Process the answer from the Receiving Server
        try {
            while (true) {
                Element doc = socketReader.getElement(RemoteServerManager.getSocketTimeout(), TimeUnit.MILLISECONDS);
                if (doc == null) {
                    log.debug( "Failed to authenticate domain: Time out waiting for validation response." );
                    return false;
                }
                else if ("db".equals(doc.getNamespacePrefix()) && "result".equals(doc.getName())) {
                    if ( "valid".equals(doc.attributeValue("type")) ) {
                        log.debug( "Authenticated succeeded!" );
                        return true;
                    } else {
                        log.debug( "Failed to authenticate domain: the validation response was received, but did not grant authentication." );
                        return false;
                    }
                }
                else {
                    log.warn( "Ignoring unexpected answer while waiting for dialback validation: " + doc.asXML() );
                }
            }
        }
        catch (InterruptedException e) {
            log.debug( "Failed to authenticate domain: An interrupt was received while waiting for validation response (is Openfire shutting down?)" );
            return false;
        }
    }
}
 

import org.jivesoftware.openfire.auth.AuthFactory; //导入方法依赖的package包/类
/**
 * Authenticates the Originating Server domain with the Receiving Server. Once the domain has
 * been authenticated the Receiving Server will start accepting packets from the Originating
 * Server.<p>
 *
 * The Receiving Server will connect to the Authoritative Server to verify the dialback key.
 * Most probably the Originating Server machine will be the Authoritative Server too.
 *
 * @param socketReader the reader to use for reading the answer from the Receiving Server.
 * @param domain the domain to authenticate.
 * @param hostname the hostname of the remote server (i.e. Receiving Server).
 * @param id the stream id to be used for creating the dialback key.
 * @return true if the Receiving Server authenticated the domain with the Authoritative Server.
 */
public boolean authenticateDomain(OutgoingServerSocketReader socketReader, String domain,
        String hostname, String id) {
    String key = AuthFactory.createDigest(id, getSecretkey());
    Log.debug("ServerDialback: OS - Sent dialback key to host: " + hostname + " id: " + id + " from domain: " +
            domain);

    synchronized (socketReader) {
        // Send a dialback key to the Receiving Server
        StringBuilder sb = new StringBuilder();
        sb.append("<db:result");
        sb.append(" from=\"").append(domain).append("\"");
        sb.append(" to=\"").append(hostname).append("\">");
        sb.append(key);
        sb.append("</db:result>");
        connection.deliverRawText(sb.toString());

        // Process the answer from the Receiving Server
        try {
        	while (true) {
             Element doc = socketReader.getElement(RemoteServerManager.getSocketTimeout(),
                     TimeUnit.MILLISECONDS);
             if (doc == null) {
                 Log.debug("ServerDialback: OS - Time out waiting for answer in validation from: " + hostname +
                         " id: " +
                         id +
                         " for domain: " +
                         domain);
                 return false;
             }
             else if ("db".equals(doc.getNamespacePrefix()) && "result".equals(doc.getName())) {
                 boolean success = "valid".equals(doc.attributeValue("type"));
                 Log.debug("ServerDialback: OS - Validation " + (success ? "GRANTED" : "FAILED") + " from: " +
                         hostname +
                         " id: " +
                         id +
                         " for domain: " +
                         domain);
                 return success;
             }
             else {
                 Log.warn("ServerDialback: OS - Ignoring unexpected answer in validation from: " + hostname + " id: " +
                         id +
                         " for domain: " +
                         domain +
                         " answer:" +
                         doc.asXML());
             }
        	}
        }
        catch (InterruptedException e) {
            Log.debug("ServerDialback: OS - Validation FAILED from: " + hostname +
                    " id: " +
                    id +
                    " for domain: " +
                    domain, e);
            return false;
        }
    }
}