Java Request.setAuthType方法代码示例

import org.apache.catalina.connector.Request; //导入方法依赖的package包/类
/**
 * Attempts reauthentication to the given <code>Realm</code> using the
 * credentials associated with the single sign-on session identified by
 * argument <code>ssoId</code>.
 * <p>
 * If reauthentication is successful, the <code>Principal</code> and
 * authorization type associated with the SSO session will be bound to the
 * given <code>Request</code> object via calls to {@link Request#setAuthType
 * Request.setAuthType()} and {@link Request#setUserPrincipal
 * Request.setUserPrincipal()}
 * </p>
 *
 * @param ssoId
 *            identifier of SingleSignOn session with which the caller is
 *            associated
 * @param realm
 *            Realm implementation against which the caller is to be
 *            authenticated
 * @param request
 *            the request that needs to be authenticated
 * 
 * @return <code>true</code> if reauthentication was successful,
 *         <code>false</code> otherwise.
 */
protected boolean reauthenticate(String ssoId, Realm realm, Request request) {

	if (ssoId == null || realm == null) {
		return false;
	}

	boolean reauthenticated = false;

	SingleSignOnEntry entry = cache.get(ssoId);
	if (entry != null && entry.getCanReauthenticate()) {

		String username = entry.getUsername();
		if (username != null) {
			Principal reauthPrincipal = realm.authenticate(username, entry.getPassword());
			if (reauthPrincipal != null) {
				reauthenticated = true;
				// Bind the authorization credentials to the request
				request.setAuthType(entry.getAuthType());
				request.setUserPrincipal(reauthPrincipal);
			}
		}
	}

	return reauthenticated;
}
 

import org.apache.catalina.connector.Request; //导入方法依赖的package包/类
/**
 * Attempts reauthentication to the given <code>Realm</code> using
 * the credentials associated with the single sign-on session
 * identified by argument <code>ssoId</code>.
 * <p>
 * If reauthentication is successful, the <code>Principal</code> and
 * authorization type associated with the SSO session will be bound
 * to the given <code>Request</code> object via calls to 
 * {@link Request#setAuthType Request.setAuthType()} and 
 * {@link Request#setUserPrincipal Request.setUserPrincipal()}
 * </p>
 *
 * @param ssoId     identifier of SingleSignOn session with which the
 *                  caller is associated
 * @param realm     Realm implementation against which the caller is to
 *                  be authenticated
 * @param request   the request that needs to be authenticated
 * 
 * @return  <code>true</code> if reauthentication was successful,
 *          <code>false</code> otherwise.
 */
protected boolean reauthenticate(String ssoId, Realm realm,
                                 Request request) {

    if (ssoId == null || realm == null) {
        return false;
    }

    boolean reauthenticated = false;

    SingleSignOnEntry entry = cache.get(ssoId);
    if (entry != null && entry.getCanReauthenticate()) {
        
        String username = entry.getUsername();
        if (username != null) {
            Principal reauthPrincipal =
                    realm.authenticate(username, entry.getPassword());                
            if (reauthPrincipal != null) {                    
                reauthenticated = true;                    
                // Bind the authorization credentials to the request
                request.setAuthType(entry.getAuthType());
                request.setUserPrincipal(reauthPrincipal);
            }
        }
    }

    return reauthenticated;
}
 

import org.apache.catalina.connector.Request; //导入方法依赖的package包/类
/**
 * Attempts reauthentication to the given <code>Realm</code> using
 * the credentials associated with the single sign-on session
 * identified by argument <code>ssoId</code>.
 * <p>
 * If reauthentication is successful, the <code>Principal</code> and
 * authorization type associated with the SSO session will be bound
 * to the given <code>Request</code> object via calls to 
 * {@link Request#setAuthType Request.setAuthType()} and 
 * {@link Request#setUserPrincipal Request.setUserPrincipal()}
 * </p>
 *
 * @param ssoId     identifier of SingleSignOn session with which the
 *                  caller is associated
 * @param realm     Realm implementation against which the caller is to
 *                  be authenticated
 * @param request   the request that needs to be authenticated
 * 
 * @return  <code>true</code> if reauthentication was successful,
 *          <code>false</code> otherwise.
 */
public boolean reauthenticate(String ssoId, Realm realm,
                                 Request request) {

    if (ssoId == null || realm == null)
        return false;

    boolean reauthenticated = false;

    SingleSignOnEntry entry = lookup(ssoId);
    if (entry != null && entry.getCanReauthenticate()) {
        
        String username = entry.getUsername();
        if (username != null) {
            Principal reauthPrincipal =
                    realm.authenticate(username, entry.getPassword());                
            if (reauthPrincipal != null) {                    
                reauthenticated = true;                    
                // Bind the authorization credentials to the request
                request.setAuthType(entry.getAuthType());
                request.setUserPrincipal(reauthPrincipal);
            }
        }
    }

    return reauthenticated;
}
 

import org.apache.catalina.connector.Request; //导入方法依赖的package包/类
private boolean doAuthentication(final Request request) {
    String token = request.getHeader("Authorization");
    if (token == null) {
        log.info("Request did not contain any token.");
        return false;
    }

    final String[] tokenParts = token.split(" ");
    if (tokenParts.length != 2 || !tokenParts[0].equalsIgnoreCase("bearer")) {
        log.info("Token was malformed. Token: " + token);
        return false;
    }

    // strip bearer off of the token
    token = tokenParts[1];

    // check if we have a static token that matches
    if (this.staticTokenMap.containsKey(token)) {
        log.info("Site verified using static token.");
        setUserRolesFromStaticToken(request, this.staticTokenMap.get(token));
        request.setAuthType("SYN");
        return true;
    }

    final Verifier verifier = Verifier.create(token);
    if (verifier == null) {
        log.info("Token rejected for not containing correct claims.");
        return false;
    }

    final String url = verifier.getUrl();
    Algorithm algorithm = null;
    if (algorithmMap.containsKey(url)) {
        algorithm = algorithmMap.get(url);
    } else if (algorithmMap.containsKey(null)) {
        algorithm = algorithmMap.get(null);
    }

    if (algorithm == null) {
        log.info("No key found for site: " + url + ".");
        return false;
    }

    if (verifier.verify(algorithm)) {
        log.info("Site verified: " + url);
        setUserRolesFromToken(request, verifier);
        request.setAuthType("SYN");
        return true;
    } else {
        log.info("Token failed signature verification: " + url);
        return false;
    }
}
 

import org.apache.catalina.connector.Request; //导入方法依赖的package包/类
/**
 * Perform single-sign-on support processing for this request.
 *
 * @param request The servlet request we are processing
 * @param response The servlet response we are creating
 *
 * @exception IOException if an input/output error occurs
 * @exception ServletException if a servlet error occurs
 */
public void invoke(Request request, Response response)
    throws IOException, ServletException {

    request.removeNote(Constants.REQ_SSOID_NOTE);

    // Has a valid user already been authenticated?
    if (request.getUserPrincipal() != null) {
        getNext().invoke(request, response);
        return;
    }

    // Check for the single sign on cookie
    Cookie cookie = null;
    Cookie cookies[] = request.getCookies();
    if (cookies == null)
        cookies = new Cookie[0];
    for (int i = 0; i < cookies.length; i++) {
        if (Constants.SINGLE_SIGN_ON_COOKIE.equals(cookies[i].getName())) {
            cookie = cookies[i];
            break;
        }
    }
    if (cookie == null) {
        getNext().invoke(request, response);
        return;
    }

    // Look up the cached Principal associated with this cookie value
    SingleSignOnEntry entry = lookup(cookie.getValue());
    if (entry != null) {
        request.setNote(Constants.REQ_SSOID_NOTE, cookie.getValue());
        // Only set security elements if reauthentication is not required
        if (!getRequireReauthentication()) {
            request.setAuthType(entry.getAuthType());
            request.setUserPrincipal(entry.getPrincipal());
        }
    } else {
        cookie.setMaxAge(0);
        response.addCookie(cookie);
    }

    // Invoke the next Valve in our pipeline
    getNext().invoke(request, response);

}