Java AssociationSessionType类代码示例

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
private void reconnectToMxID() {
	LOG.info("Starting OpenId handler ... OpenIDReturnURL = " + OPENID_RETURN_URL + "; OpenIdProvider: " + OPENID_PROVIDER);
	try {

		manager = new ConsumerManager();
		manager.setAssociations(new InMemoryConsumerAssociationStore());
		manager.setNonceVerifier(new InMemoryNonceVerifier(5000));
		manager.setMinAssocSessEnc(AssociationSessionType.DH_SHA256);
		manager.getRealmVerifier().setEnforceRpId(true);

		discoveries = manager.discover(OPENID_PROVIDER);
		discovered = manager.associate(discoveries);

		started = true;
		LOG.info("Starting OpenId handler ... DONE");

	} catch (DiscoveryException e) {
		LOG.error("Failed to discover OpenId service: " + e.getMessage(), e);
	}
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
public static AssociationError createAssociationError(
        String msg, AssociationSessionType type)
{
    AssociationError err = new AssociationError(msg, type);

    try
    {
        err.validate();
    }
    catch (MessageException e)
    {
        _log.error("Invalid association error message created, " +
                   "type: " + type + " message: " + msg, e);
    }

    return err;
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
public static AssociationRequest createAssociationRequest(
        AssociationSessionType type, DiffieHellmanSession dhSess)
        throws MessageException
{
    AssociationRequest req = new AssociationRequest(type, dhSess);

    // make sure the association / session type matches the dhSess
    if ( type == null ||
            (dhSess == null && type.getHAlgorithm() != null) ||
            (dhSess != null && ! dhSess.getType().equals(type) ) )
        throw new MessageException(
                "Invalid association / session combination specified: " +
                        type + "DH session: " + dhSess);

    req.validate();

    if (DEBUG) _log.debug("Created association request:\n"
                          + req.keyValueFormEncoding());

    return req;
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
@Inject
public ConsumerManager(RealmVerifierFactory realmFactory, Discovery discovery,
    HttpFetcherFactory httpFetcherFactory)
{
    _realmVerifier = realmFactory.getRealmVerifierForConsumer();
    // don't verify own (RP) identity, disable RP discovery
    _realmVerifier.setEnforceRpId(false);

    _discovery = discovery;
    _httpFetcher = httpFetcherFactory.createFetcher(HttpRequestOptions.getDefaultOptionsForOpCalls());

    if (Association.isHmacSha256Supported())
        _prefAssocSessEnc = AssociationSessionType.DH_SHA256;
    else
        _prefAssocSessEnc = AssociationSessionType.DH_SHA1;
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void init(ServletConfig config) throws ServletException {
	super.init(config);

	context = config.getServletContext();

	LOG.debug("context: " + context);

	// --- Forward proxy setup (only if needed) ---
	ProxyProperties proxyProps = getProxyProperties(config);
	if (proxyProps != null) {
		LOG.debug("ProxyProperties: " + proxyProps);
		HttpClientFactory.setProxyProperties(proxyProps);
	}

	this.manager = new ConsumerManager();
	manager.setAssociations(new InMemoryConsumerAssociationStore());
	manager.setNonceVerifier(new InMemoryNonceVerifier(5000));
	manager.setMinAssocSessEnc(AssociationSessionType.DH_SHA256);
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
private void reconnectToMxID() {
	log.info("Starting OpenId handler ... OpenIDReturnURL = " + OpenIDReturnURL + "; OpenIdProvider: " + OPENID_PROVIDER);
	try {

		manager = new ConsumerManager();
		manager.setAssociations(new InMemoryConsumerAssociationStore());
		manager.setNonceVerifier(new InMemoryNonceVerifier(5000));
		manager.setMinAssocSessEnc(AssociationSessionType.DH_SHA256);
		manager.getRealmVerifier().setEnforceRpId(true);

		discoveries = manager.discover(OPENID_PROVIDER);
		discovered = manager.associate(discoveries);

		started = true;
		log.info("Starting OpenId handler ... DONE");

	} catch (Exception e) {
		log.error("Failed to discover OpenId service: " + e.getMessage(), e);
	}
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
public void init(FilterConfig config) throws ServletException {
    super.init(config);
    try 
    {
        this.manager = new ConsumerManager();
    } catch (ConsumerException ex) {
        throw new ServletException(ex);
    }
    manager.setAssociations(new InMemoryConsumerAssociationStore());
    manager.setNonceVerifier(new InMemoryNonceVerifier(5000));
    manager.setMinAssocSessEnc(AssociationSessionType.DH_SHA256);
    manager.setImmediateAuth(true);
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
/**
 * Constructs an AssociationResponse for a given association request.
 *
 * @param assocReq      The association request that needs to be responded.
 * @param assoc         The association which will be used to sign
 *                      authentication responses.
 */
protected AssociationResponse(AssociationRequest assocReq, Association assoc)
        throws AssociationException
{
    if (DEBUG)
        _log.debug("Creating association response, type: " + assocReq.getType()
                   + " association handle: " + assoc.getHandle());

    if (assocReq.isVersion2()) set("ns", OPENID2_NS);

    AssociationSessionType type = assocReq.getType();
    setType(type);

    setAssocHandle(assoc.getHandle());

    Long expiryIn = new Long( ( assoc.getExpiry().getTime() -
                                System.currentTimeMillis() ) / 1000 );
    setExpire(expiryIn);

    if (type.getHAlgorithm() != null) // DH session, encrypt the MAC key
    {
        DiffieHellmanSession dhSess = DiffieHellmanSession.create(
                type, assocReq.getDhModulus(), assocReq.getDhGen() );

        setPublicKey(dhSess.getPublicKey());

        setMacKeyEnc(dhSess.encryptMacKey(
                assoc.getMacKey().getEncoded(),
                assocReq.getDhPublicKey() ));
    }
    else // no-encryption session, unecrypted MAC key
    {
        setMacKey(new String(
                Base64.encodeBase64(assoc.getMacKey().getEncoded())));
    }
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
protected AssociationError(String msg, AssociationSessionType type)
{
    super(msg);

    set("ns", OPENID2_NS);
    set("error_code", ASSOC_ERR);
    set("session_type", type.getSessionType());
    set("assoc_type", type.getAssociationType());
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
/**
 * Constructs an AssociationRequest message with the
 * specified association type and Diffie-Hellman session.
 *
 * @param dhSess    Diffie-Hellman session to be used for this association;
 *                  if null, a "no-encryption" session is created.
 */
protected AssociationRequest(AssociationSessionType type,
                             DiffieHellmanSession dhSess)
{
    if (DEBUG)
        _log.debug("Creating association request, type: " + type +
                   "DH session: " + dhSess);

    if (type.isVersion2())
        set("openid.ns", OPENID2_NS);

    set("openid.mode", MODE_ASSOC);
    set("openid.session_type", type.getSessionType());
    set("openid.assoc_type", type.getAssociationType());

    _dhSess = dhSess;

    if (dhSess != null )
    {
        set("openid.dh_consumer_public", _dhSess.getPublicKey());

        // send both diffie-hellman generator and modulus if either are not the default values
        // (this meets v1.1 spec and is compatible with v2.0 spec)

        if (!DiffieHellmanSession.DEFAULT_GENERATOR_BASE64.equals(_dhSess.getGenerator())
                || !DiffieHellmanSession.DEFAULT_MODULUS_BASE64.equals(_dhSess.getModulus()))
        {
            set("openid.dh_gen", _dhSess.getGenerator());
            set("openid.dh_modulus", _dhSess.getModulus());
        }
    }
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
/**
 * Constructs an Association Request message of the specified session and
 * association type, taking into account the user preferences (encryption
 * level, default Diffie-Hellman parameters).
 *
 * @param type      The type of the association (session and association)
 * @param opUrl    The OP for which the association request is created
 * @return          An AssociationRequest message ready to be sent back
 *                  to the OpenID Provider, or null if an association
 *                  of the requested type cannot be built.
 */
private AssociationRequest createAssociationRequest(
        AssociationSessionType type, URL opUrl)
{
    try
    {
        if (_minAssocSessEnc.isBetter(type))
            return null;

        AssociationRequest assocReq = null;

        DiffieHellmanSession dhSess;
        if (type.getHAlgorithm() != null) // DH session
        {
            dhSess = DiffieHellmanSession.create(type, _dhParams);
            if (DiffieHellmanSession.isDhSupported(type)
                && Association.isHmacSupported(type.getAssociationType()))
                assocReq = AssociationRequest.createAssociationRequest(type, dhSess);
        }

        else if ( opUrl.getProtocol().equals("https") && // no-enc sess
                 Association.isHmacSupported(type.getAssociationType()))
                assocReq = AssociationRequest.createAssociationRequest(type);

        if (assocReq == null)
            _log.warn("Could not create association of type: " + type);

        return assocReq;
    }
    catch (OpenIDException e)
    {
        _log.error("Error trying to create association request.", e);
        return null;
    }
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
/**
 * Sets the preferred association / session type.
 *
 * @see AssociationSessionType
 */
public void setPrefAssocSessEnc(AssociationSessionType type)
        throws ServerException
{
    if (! Association.isHmacSupported(type.getAssociationType()) ||
        ! DiffieHellmanSession.isDhSupported(type) )
        throw new ServerException("Unsupported association / session type: "
        + type.getSessionType() + " : " + type.getAssociationType());

    if (_minAssocSessEnc.isBetter(type) )
        throw new ServerException(
                "Minimum encryption settings cannot be better than the preferred");

    this._prefAssocSessEnc = type;
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
public void testPerferredAssociation() throws Exception {
	manager.setPrefAssocSessEnc(AssociationSessionType.DH_SHA1);
	DiscoveryInformation disc = new DiscoveryInformation(new URL(server.createAbsoluteUrl("/op/endpoint")), null);
	DiscoveryInformation info = manager.associate(Collections.singletonList(disc));
	assertEquals(1,server.getRequestParams().size());
	Map request = (Map)server.getRequestParams().get(0);
	assertEquals(manager.getPrefAssocSessEnc().getAssociationType(),((String[])request.get("openid.assoc_type"))[0]);
	assertEquals(manager.getPrefAssocSessEnc().getSessionType(),((String[])request.get("openid.session_type"))[0]);
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
/**
 * Sets the association / session type for the association response.
 */
public void setType(AssociationSessionType type)
{
    set("session_type", type.getSessionType());
    set("assoc_type", type.getAssociationType());
}
 

import org.openid4java.association.AssociationSessionType; //导入依赖的package包/类
/**
 * Gets the association / session type of the association response.
 *
 * @throws AssociationException
 */
public AssociationSessionType getType() throws AssociationException
{
    return AssociationSessionType.create(
            getSessionType(), getAssociationType(), ! isVersion2() );
}