attr.isRequired(), attr.getCount()); authReq.addExtension(fetchRequest); return authReq.getDestinationUrl(true);
public static AuthRequest createAuthRequest(String claimedId, String delegate, boolean compatibility, String returnToUrl, String handle, String realm, RealmVerifier verifier) throws MessageException { AuthRequest req = new AuthRequest(claimedId, delegate, compatibility, returnToUrl, handle, realm, verifier); req.validate(); if (DEBUG) _log.debug("Created auth request:\n" + req.keyValueFormEncoding()); return req; }
@Override public Message authResponse(AuthRequest authReq, String userSelId, String userSelClaimed, boolean authenticatedAndApproved, String opEndpoint, boolean signNow) { if(log.isDebugEnabled()) { log.debug("Association handle in AuthRequest : " + authReq.getHandle()); } return super.authResponse(authReq, userSelId, userSelClaimed, authenticatedAndApproved, opEndpoint, signNow); }
authReq.addExtension(fetch); httpResp.sendRedirect(authReq.getDestinationUrl(true)); } else { sendFormRedirect(httpResp, authReq.getDestinationUrl(false), (Map<String,String>)authReq.getParameterMap());
boolean isVersion2 = authReq.isVersion2(); if (authReq.getReturnTo() == null) { _log.error("No return_to in the received (valid) auth request; " + "returning null auth response."); if (AuthRequest.SELECT_ID.equals(authReq.getIdentity())) { id = userSelId; claimed = userSelClaimed; } else { id = userSelId != null ? userSelId : authReq.getIdentity(); claimed = userSelClaimed != null ? userSelClaimed : authReq.getClaimed(); String handle = authReq.getHandle(); String invalidateHandle = null; authReq.getReturnTo(), isVersion2 ? _nonceGenerator.next() : null, invalidateHandle, assoc, false); if (authReq.isImmediate()) { _log.error("Responding with immediate authentication " + "failure to " + authReq.getReturnTo()); authReq.setImmediate(false); _userSetupUrl + separator + authReq.wwwFormEncoding(), authReq.getReturnTo(), !isVersion2);
authReq.setRealm(realm); authReq.addExtension(fetchRequest); return authReq.getDestinationUrl(true);
boolean compatibility = !isVersion2(); if (compatibility && hasParameter("openid.identity") && SELECT_ID.equals(getParameterValue("openid.identity"))) { throw new MessageException(SELECT_ID + " not supported in OpenID1", OpenIDException.AUTH_ERROR); if (hasParameter("openid.mode") && !MODE_SETUP.equals(getParameterValue("openid.mode")) && !MODE_IMMEDIATE.equals(getParameterValue("openid.mode"))) { throw new MessageException( "Invalid openid.mode value in auth request: " + getParameterValue("openid.mode"), OpenIDException.AUTH_ERROR); if (getReturnTo() != null) { new URL(getReturnTo()); if (!hasParameter("openid.return_to")) { if (compatibility) { throw new MessageException( "openid.return_to is mandatory in OpenID1 auth requests", OpenIDException.AUTH_ERROR); } else if (!hasParameter("openid.realm")) { throw new MessageException( "openid.realm is mandatory if return_to is absent.", if (compatibility && hasParameter("openid.realm")) { _log.warn("openid.realm should not be present in OpenID1 auth requests");
authReq.setHandle(""); true); // required authReq.addExtension(fetch); sregReq.addAttribute("email", true); authReq.addExtension(sregReq); userDTO.getParams().put(OpenIDUserDTO.ENDPOINT_URL, authReq.getDestinationUrl(true));
AuthRequest.createAuthRequest(request, manager.getRealmVerifier()); userSelectedClaimedId.equals(authReq.getClaimed())) { return directResponse(httpResp, response.keyValueFormEncoding()); } else { if (authReq.hasExtension(AxMessage.OPENID_NS_AX)) { MessageExtension ext = authReq.getExtension(AxMessage.OPENID_NS_AX); if (ext instanceof FetchRequest) { FetchRequest fetchReq = (FetchRequest) ext; if (authReq.hasExtension(SRegMessage.OPENID_NS_SREG)) { MessageExtension ext = authReq.getExtension(SRegMessage.OPENID_NS_SREG); if (ext instanceof SRegRequest) { SRegRequest sregReq = (SRegRequest) ext;
/** * @param authRequest OpenID authentication request * @return A set of policies requested * @throws IdentityException */ public static String[] getAuthenticationPolicies(AuthRequest authRequest) throws IdentityException { MessageExtension message = null; PapeRequest papeRequest = null; List preferredPolicies = null; try { if (authRequest.hasExtension(PapeMessage.OPENID_NS_PAPE)) { message = authRequest.getExtension(PapeMessage.OPENID_NS_PAPE); if (message instanceof PapeRequest) { papeRequest = (PapeRequest) message; preferredPolicies = papeRequest.getPreferredAuthPoliciesList(); if (preferredPolicies != null && !preferredPolicies.isEmpty()) { return (String[]) preferredPolicies.toArray(new String[preferredPolicies.size()]); } } } return new String[0]; } catch (MessageException e) { throw IdentityException.error("Failed retrieve authentication policies", e); } }
AuthRequest authRequest = AuthRequest.createAuthRequest(parameterList, realmVerifier); String returnTo = authRequest.getReturnTo(); if (null != returnTo && null != referer) { if (authRequest.hasExtension(UserInterfaceMessage.OPENID_NS_UI)) { .getExtension(UserInterfaceMessage.OPENID_NS_UI); if (authRequest.hasExtension(AxMessage.OPENID_NS_AX)) { .getExtension(AxMessage.OPENID_NS_AX); openidRealm = authRequest.getReturnTo();
returnToUrl = insertConsumerNonce(discovered.getOPEndpoint().toString(), returnToUrl); AuthRequest authReq = AuthRequest.createAuthRequest(claimedId, delegate, ! discovered.isVersion2(), returnToUrl, handle, realm, _realmVerifier); authReq.setOPEndpoint(discovered.getOPEndpoint()); authReq.setImmediate(_immediateAuth);
// enable oauth ext for openid4java (do once) Message.addExtensionFactory(OAuthMessage.class); // add oauth extension to open-id request AuthRequest authReq = ...; OAuthRequest oauthRequest = OAuthRequest.createOAuthRequest(); oauthRequest.setScopes("oauth scope"); oauthRequest.setConsumer("oauth consumer key"); authReq.addExtension(oauthRequest); // extract oauth request token from open-id response AuthSuccess authSuccess = ...; if (authSuccess.hasExtension(OAuthMessage.OPENID_NS_OAUTH)) { OAuthResponse oauthRes = (OAuthResponse) authSuccess .getExtension(OAuthMessage.OPENID_NS_OAUTH); // use this request token (without secret and verifier) and your oauth lib // to get oauth access token String oauthRequestToken = oauthRes.getRequestToken(); }
public void redirect(String openId) { discoveryInformation = performDiscovery(openId); AuthRequest authRequest = createOpenIdAuthRequest(); WicketUtils.performTemporaryRedirect(authRequest.getDestinationUrl(true)); }
public static AuthRequest createAuthRequest(String claimedId, String delegate, boolean compatibility, String returnToUrl, String handle, RealmVerifier verifier) throws MessageException { return createAuthRequest(claimedId, delegate, compatibility, returnToUrl, handle, returnToUrl, verifier); }
/** * Gets association. * * @param serverManager the server manager * @return the association */ protected Association getAssociation(final ServerManager serverManager) { try { final AuthRequest authReq = AuthRequest.createAuthRequest(this.parameterList, serverManager.getRealmVerifier()); final Map parameterMap = authReq.getParameterMap(); if (parameterMap != null && !parameterMap.isEmpty()) { final String assocHandle = (String) parameterMap.get(OpenIdProtocolConstants.OPENID_ASSOCHANDLE); if (assocHandle != null) { return serverManager.getSharedAssociations().load(assocHandle); } } } catch (final MessageException me) { LOGGER.error("Message exception : {}", me.getMessage(), me); } return null; }
manager = OpenIDProvider.getInstance().getManager(); try { authReq = AuthRequest.createAuthRequest(paramList, manager.getRealmVerifier()); } catch (MessageException e) { throw new IdentityProviderException("Error while creating authentication request", e); for (Object alias : authReq.getExtensions()) { req.setExtensionAlias((String) alias);
message = authRequest.getExtension(PapeMessage.OPENID_NS_PAPE);
/** * @param authRequest * @return * @throws IdentityException */ private List<String> getRequestedAttributes(AuthRequest authRequest) throws IdentityException { OpenIDAuthenticationRequest req = null; OpenIDExtension extension = null; List<String> requiredAttributes = null; req = new OpenIDAuthenticationRequest(); req.setAuthRequest(authRequest); requiredAttributes = new ArrayList<String>(); for (Object alias : authRequest.getExtensions()) { req.setExtensionAlias((String) alias); extension = OpenIDExtensionFactory.getInstance().getExtension(req); if (extension != null) { extension.addRequiredAttributes(requiredAttributes); } } return requiredAttributes; }
authReq.addExtension(sregReq); adapter.sendToProvider(1, authReq.getDestinationUrl(true), null); return true; } else { adapter.sendToProvider(2, authReq.getDestinationUrl(false), authReq.getParameterMap());