private OAuthAppDO getAppInformation(OAuth2AccessTokenReqDTO tokenReqDTO)
     throws IdentityOAuth2Exception, InvalidOAuthClientException {
   OAuthAppDO oAuthAppDO = appInfoCache.getValueFromCache(tokenReqDTO.getClientId());
   if (oAuthAppDO != null) {
     return oAuthAppDO;
   } else {
     oAuthAppDO = new OAuthAppDAO().getAppInformation(tokenReqDTO.getClientId());
     appInfoCache.addToCache(tokenReqDTO.getClientId(), oAuthAppDO);
     return oAuthAppDO;
   }
 }
  private void addUserAttributesToCache(
      OAuth2AccessTokenReqDTO tokenReqDTO, OAuth2AccessTokenRespDTO tokenRespDTO) {
    AuthorizationGrantCacheKey oldCacheKey =
        new AuthorizationGrantCacheKey(tokenReqDTO.getAuthorizationCode());
    // checking getUserAttributesId vale of cacheKey before retrieve entry from cache as it causes
    // to NPE
    if (oldCacheKey.getUserAttributesId() != null) {
      AuthorizationGrantCacheEntry authorizationGrantCacheEntry =
          AuthorizationGrantCache.getInstance().getValueFromCacheByCode(oldCacheKey);
      AuthorizationGrantCacheKey newCacheKey =
          new AuthorizationGrantCacheKey(tokenRespDTO.getAccessToken());

      if (AuthorizationGrantCache.getInstance().getValueFromCacheByToken(newCacheKey) == null) {
        if (log.isDebugEnabled()) {
          log.debug(
              "No AuthorizationGrantCache entry found for the access token:"
                  + newCacheKey.getUserAttributesId()
                  + ", hence adding to cache");
        }
        AuthorizationGrantCache.getInstance()
            .addToCacheByToken(newCacheKey, authorizationGrantCacheEntry);
        AuthorizationGrantCache.getInstance().clearCacheEntryByCode(oldCacheKey);
      } else {
        // if the user attributes are already saved for access token, no need to add again.
      }
    }
  }
 private OAuth2AccessTokenRespDTO handleError(
     String errorCode, String errorMsg, OAuth2AccessTokenReqDTO tokenReqDTO) {
   if (log.isDebugEnabled()) {
     log.debug(
         "OAuth-Error-Code="
             + errorCode
             + " client-id="
             + tokenReqDTO.getClientId()
             + " grant-type="
             + tokenReqDTO.getGrantType()
             + " scope="
             + OAuth2Util.buildScopeString(tokenReqDTO.getScope()));
   }
   OAuth2AccessTokenRespDTO tokenRespDTO;
   tokenRespDTO = new OAuth2AccessTokenRespDTO();
   tokenRespDTO.setError(true);
   tokenRespDTO.setErrorCode(errorCode);
   tokenRespDTO.setErrorMsg(errorMsg);
   return tokenRespDTO;
 }
Exemple #4
0
  @Override
  public boolean validateGrant(OAuthTokenReqMessageContext tokReqMsgCtx)
      throws IdentityOAuth2Exception {
    OAuth2AccessTokenReqDTO oAuth2AccessTokenReqDTO = tokReqMsgCtx.getOauth2AccessTokenReqDTO();
    String username = oAuth2AccessTokenReqDTO.getResourceOwnerUsername();
    int tenantId;
    try {
      tenantId = IdentityUtil.getTenantIdOFUser(username);
    } catch (IdentityException e) {
      throw new IdentityOAuth2Exception(e.getMessage(), e);
    }

    // tenantId == -1, means an invalid tenant.
    if (tenantId == -1) {
      /*if (log.isDebugEnabled()) {
          log.debug("Token request with Password Grant Type for an invalid tenant : " +
                  MultitenantUtils.getTenantDomain(username));
      }
      return false;*/
      tenantId = MultitenantConstants.SUPER_TENANT_ID;
    }

    RealmService realmService = OAuthComponentServiceHolder.getRealmService();
    boolean authStatus;
    try {
      UserStoreManager userStoreManager =
          realmService.getTenantUserRealm(tenantId).getUserStoreManager();
      authStatus =
          userStoreManager.authenticate(
              MultitenantUtils.getTenantAwareUsername(username),
              oAuth2AccessTokenReqDTO.getResourceOwnerPassword());

      if (log.isDebugEnabled()) {
        log.debug(
            "Token request with Password Grant Type received. "
                + "Username : "******"Scope : "
                + OAuth2Util.buildScopeString(oAuth2AccessTokenReqDTO.getScope())
                + ", Authentication State : "
                + authStatus);
      }

    } catch (UserStoreException e) {
      throw new IdentityOAuth2Exception("Error when authenticating the user credentials.", e);
    }

    tokReqMsgCtx.setAuthorizedUser(oAuth2AccessTokenReqDTO.getResourceOwnerUsername());
    tokReqMsgCtx.setScope(oAuth2AccessTokenReqDTO.getScope());
    return authStatus;
  }
  private OAuth2AccessTokenRespDTO getAccessToken(CarbonOAuthTokenRequest oauthRequest) {

    OAuth2AccessTokenReqDTO tokenReqDTO = new OAuth2AccessTokenReqDTO();
    String grantType = oauthRequest.getGrantType();
    tokenReqDTO.setGrantType(grantType);
    tokenReqDTO.setClientId(oauthRequest.getClientId());
    tokenReqDTO.setClientSecret(oauthRequest.getClientSecret());
    tokenReqDTO.setCallbackURI(oauthRequest.getRedirectURI());
    tokenReqDTO.setScope(
        oauthRequest.getScopes().toArray(new String[oauthRequest.getScopes().size()]));
    tokenReqDTO.setTenantDomain(oauthRequest.getTenantDomain());

    // Check the grant type and set the corresponding parameters
    if (GrantType.AUTHORIZATION_CODE.toString().equals(grantType)) {
      tokenReqDTO.setAuthorizationCode(oauthRequest.getCode());
    } else if (GrantType.PASSWORD.toString().equals(grantType)) {
      tokenReqDTO.setResourceOwnerUsername(oauthRequest.getUsername());
      tokenReqDTO.setResourceOwnerPassword(oauthRequest.getPassword());
    } else if (GrantType.REFRESH_TOKEN.toString().equals(grantType)) {
      tokenReqDTO.setRefreshToken(oauthRequest.getRefreshToken());
    } else if (org.wso2.carbon.identity.oauth.common.GrantType.SAML20_BEARER
        .toString()
        .equals(grantType)) {
      tokenReqDTO.setAssertion(oauthRequest.getAssertion());
    } else if (org.wso2.carbon.identity.oauth.common.GrantType.IWA_NTLM
        .toString()
        .equals(grantType)) {
      tokenReqDTO.setWindowsToken(oauthRequest.getWindowsToken());
    } else {
      // Set all request parameters to the OAuth2AccessTokenReqDTO
      tokenReqDTO.setRequestParameters(oauthRequest.getRequestParameters());
    }

    return EndpointUtil.getOAuth2Service().issueAccessToken(tokenReqDTO);
  }
  /**
   * Issue access token in exchange to an Authorization Grant.
   *
   * @param tokenReqDTO <Code>OAuth2AccessTokenReqDTO</Code> representing the Access Token request
   * @return <Code>OAuth2AccessTokenRespDTO</Code> representing the Access Token response
   */
  public OAuth2AccessTokenRespDTO issueAccessToken(OAuth2AccessTokenReqDTO tokenReqDTO) {

    if (log.isDebugEnabled()) {
      log.debug(
          "Access Token request received for Client ID "
              + tokenReqDTO.getClientId()
              + ", User ID "
              + tokenReqDTO.getResourceOwnerUsername()
              + ", Scope : "
              + Arrays.toString(tokenReqDTO.getScope())
              + " and Grant Type : "
              + tokenReqDTO.getGrantType());
    }

    try {
      AccessTokenIssuer tokenIssuer = AccessTokenIssuer.getInstance();
      return tokenIssuer.issue(tokenReqDTO);
    } catch (InvalidOAuthClientException e) {
      if (log.isDebugEnabled()) {
        log.debug(
            "Error occurred while issuing access token for Client ID : "
                + tokenReqDTO.getClientId()
                + ", User ID: "
                + tokenReqDTO.getResourceOwnerUsername()
                + ", Scope : "
                + Arrays.toString(tokenReqDTO.getScope())
                + " and Grant Type : "
                + tokenReqDTO.getGrantType(),
            e);
      }
      OAuth2AccessTokenRespDTO tokenRespDTO = new OAuth2AccessTokenRespDTO();
      tokenRespDTO.setError(true);
      tokenRespDTO.setErrorCode(OAuth2ErrorCodes.INVALID_CLIENT);
      tokenRespDTO.setErrorMsg("Invalid Client");
      return tokenRespDTO;
    } catch (Exception e) { // in case of an error, consider it as a system error
      log.error(
          "Error occurred while issuing the access token for Client ID : "
              + tokenReqDTO.getClientId()
              + ", User ID "
              + tokenReqDTO.getResourceOwnerUsername()
              + ", Scope : "
              + Arrays.toString(tokenReqDTO.getScope())
              + " and Grant Type : "
              + tokenReqDTO.getGrantType(),
          e);
      OAuth2AccessTokenRespDTO tokenRespDTO = new OAuth2AccessTokenRespDTO();
      tokenRespDTO.setError(true);
      if (e.getCause().getCause() instanceof SQLIntegrityConstraintViolationException) {
        tokenRespDTO.setErrorCode("sql_error");
      } else {
        tokenRespDTO.setErrorCode(OAuth2ErrorCodes.SERVER_ERROR);
      }
      tokenRespDTO.setErrorMsg("Server Error");
      return tokenRespDTO;
    }
  }
  public OAuth2AccessTokenRespDTO issue(OAuth2AccessTokenReqDTO tokenReqDTO)
      throws IdentityException, InvalidOAuthClientException {

    String grantType = tokenReqDTO.getGrantType();
    OAuth2AccessTokenRespDTO tokenRespDTO;

    AuthorizationGrantHandler authzGrantHandler = authzGrantHandlers.get(grantType);

    OAuthTokenReqMessageContext tokReqMsgCtx = new OAuthTokenReqMessageContext(tokenReqDTO);

    // If multiple client authentication methods have been used the authorization server must reject
    // the request
    int authenticatorHandlerIndex = -1;
    for (int i = 0; i < clientAuthenticationHandlers.size(); i++) {
      if (clientAuthenticationHandlers.get(i).canAuthenticate(tokReqMsgCtx)) {
        if (authenticatorHandlerIndex > -1) {
          log.debug(
              "Multiple Client Authentication Methods used for client id : "
                  + tokenReqDTO.getClientId());
          tokenRespDTO =
              handleError(
                  OAuthConstants.OAuthError.TokenResponse.UNSUPPORTED_CLIENT_AUTHENTICATION_METHOD,
                  "Unsupported Client Authentication Method!",
                  tokenReqDTO);
          setResponseHeaders(tokReqMsgCtx, tokenRespDTO);
          return tokenRespDTO;
        }
        authenticatorHandlerIndex = i;
      }
    }
    if (authenticatorHandlerIndex < 0 && authzGrantHandler.isConfidentialClient()) {
      log.debug(
          "Confidential client cannot be authenticated for client id : "
              + tokenReqDTO.getClientId());
      tokenRespDTO =
          handleError(
              OAuthConstants.OAuthError.TokenResponse.UNSUPPORTED_CLIENT_AUTHENTICATION_METHOD,
              "Unsupported Client Authentication Method!",
              tokenReqDTO);
      setResponseHeaders(tokReqMsgCtx, tokenRespDTO);
      return tokenRespDTO;
    }

    ClientAuthenticationHandler clientAuthHandler = null;
    if (authenticatorHandlerIndex > -1) {
      clientAuthHandler = clientAuthenticationHandlers.get(authenticatorHandlerIndex);
    }
    boolean isAuthenticated;
    if (clientAuthHandler != null) {
      isAuthenticated = clientAuthHandler.authenticateClient(tokReqMsgCtx);
    } else {
      isAuthenticated = true;
    }
    if (!isAuthenticated) {
      if (log.isDebugEnabled()) {
        log.debug("Client Authentication failed for client Id: " + tokenReqDTO.getClientId());
      }
      tokenRespDTO =
          handleError(
              OAuthError.TokenResponse.INVALID_CLIENT,
              "Client credentials are invalid.",
              tokenReqDTO);
      setResponseHeaders(tokReqMsgCtx, tokenRespDTO);
      return tokenRespDTO;
    }

    // loading the stored application data
    OAuthAppDO oAuthAppDO = getAppInformation(tokenReqDTO);
    if (!authzGrantHandler.isOfTypeApplicationUser()) {
      tokReqMsgCtx.setAuthorizedUser(OAuth2Util.getUserFromUserName(oAuthAppDO.getUserName()));
      tokReqMsgCtx
          .getAuthorizedUser()
          .setTenantDomain(IdentityTenantUtil.getTenantDomain(oAuthAppDO.getTenantId()));
    }

    boolean isValidGrant = false;
    String error = "Provided Authorization Grant is invalid";
    try {
      isValidGrant = authzGrantHandler.validateGrant(tokReqMsgCtx);
    } catch (IdentityOAuth2Exception e) {
      if (log.isDebugEnabled()) {
        log.debug("Error occurred while validating grant", e);
      }
      error = e.getMessage();
    }

    if (!isValidGrant) {
      if (log.isDebugEnabled()) {
        log.debug("Invalid Grant provided by the client Id: " + tokenReqDTO.getClientId());
      }
      tokenRespDTO = handleError(OAuthError.TokenResponse.INVALID_GRANT, error, tokenReqDTO);
      setResponseHeaders(tokReqMsgCtx, tokenRespDTO);
      return tokenRespDTO;
    }

    boolean isAuthorized = authzGrantHandler.authorizeAccessDelegation(tokReqMsgCtx);
    if (!isAuthorized) {
      if (log.isDebugEnabled()) {
        log.debug("Invalid authorization for client Id = " + tokenReqDTO.getClientId());
      }
      tokenRespDTO =
          handleError(
              OAuthError.TokenResponse.UNAUTHORIZED_CLIENT, "Unauthorized Client!", tokenReqDTO);
      setResponseHeaders(tokReqMsgCtx, tokenRespDTO);
      return tokenRespDTO;
    }

    boolean isValidScope = authzGrantHandler.validateScope(tokReqMsgCtx);
    if (!isValidScope) {
      if (log.isDebugEnabled()) {
        log.debug("Invalid scope provided by client Id: " + tokenReqDTO.getClientId());
      }
      tokenRespDTO =
          handleError(OAuthError.TokenResponse.INVALID_SCOPE, "Invalid Scope!", tokenReqDTO);
      setResponseHeaders(tokReqMsgCtx, tokenRespDTO);
      return tokenRespDTO;
    }

    try {
      // set the token request context to be used by downstream handlers. This is introduced as a
      // fix for
      // IDENTITY-4111.
      OAuth2Util.setTokenRequestContext(tokReqMsgCtx);
      tokenRespDTO = authzGrantHandler.issue(tokReqMsgCtx);
    } finally {
      // clears the token request context.
      OAuth2Util.clearTokenRequestContext();
    }

    tokenRespDTO.setCallbackURI(oAuthAppDO.getCallbackUrl());

    String[] scopes = tokReqMsgCtx.getScope();
    if (scopes != null && scopes.length > 0) {
      StringBuilder scopeString = new StringBuilder("");
      for (String scope : scopes) {
        scopeString.append(scope);
        scopeString.append(" ");
      }
      tokenRespDTO.setAuthorizedScopes(scopeString.toString().trim());
    }

    setResponseHeaders(tokReqMsgCtx, tokenRespDTO);

    // Do not change this log format as these logs use by external applications
    if (log.isDebugEnabled()) {
      log.debug(
          "Access token issued to client Id: "
              + tokenReqDTO.getClientId()
              + " username: "******" and scopes: "
              + tokenRespDTO.getAuthorizedScopes());
    }

    if (tokReqMsgCtx.getScope() != null && OAuth2Util.isOIDCAuthzRequest(tokReqMsgCtx.getScope())) {
      IDTokenBuilder builder =
          OAuthServerConfiguration.getInstance().getOpenIDConnectIDTokenBuilder();
      tokenRespDTO.setIDToken(builder.buildIDToken(tokReqMsgCtx, tokenRespDTO));
    }

    if (tokenReqDTO.getGrantType().equals(GrantType.AUTHORIZATION_CODE.toString())) {
      addUserAttributesToCache(tokenReqDTO, tokenRespDTO);
    }

    return tokenRespDTO;
  }