org.xdi.oxauth.service.GrantService クラス

org.xdi.oxauth.service.GrantService 連携図

公開メンバ関数
String	buildDn (String p_uniqueIdentifier, String p_grantId, String p_clientId)
String	baseDn ()
void	merge (TokenLdap p_token)
void	mergeSilently (TokenLdap p_token)
void	persist (TokenLdap token)
ClientTokens	getCacheClientTokens (String clientId)
SessionTokens	getCacheSessionTokens (String sessionDn)
void	remove (Grant grant)
void	remove (TokenLdap p_token)
void	removeSilently (TokenLdap token)
void	removeGrants (List< Grant > entries)
void	remove (List< TokenLdap > p_entries)
void	removeSilently (List< TokenLdap > p_entries)
void	remove (AuthorizationGrant p_grant)
List< TokenLdap >	getGrantsOfClient (String p_clientId)
TokenLdap	getGrantsByCodeAndClient (String p_code, String p_clientId)
TokenLdap	getGrantsByCode (String p_code)
TokenLdap	getGrantsByCode (String p_code, boolean onlyFromCache)
List< TokenLdap >	getGrantsByGrantId (String p_grantId)
List< TokenLdap >	getGrantsByAuthorizationCode (String p_authorizationCode)
List< TokenLdap >	getGrantsBySessionDn (String sessionDn)
List< TokenLdap >	getGrantsFromCacheBySessionDn (String sessionDn)
List< TokenLdap >	getCacheClientTokensEntries (String clientId)
List< TokenLdap >	getCacheTokensEntries (Set< String > tokenHashes)
void	removeAllTokensBySession (String sessionDn)
void	removeByCode (String p_code, String p_clientId)
void	removeAllByAuthorizationCode (String p_authorizationCode)
void	removeAllByGrantId (String p_grantId)
void	cleanUp ()

静的公開メンバ関数
static String	generateGrantId ()

非公開メンバ関数
boolean	shouldPutInCache (TokenType tokenType, boolean isImplicitFlow)
TokenLdap	load (String p_baseDn, String p_code)
Filter	getExpiredTokenFilter ()
Filter	getExpiredGrantFilter ()
Filter	getExpiredOldGrantFilter ()
void	addGrantBranch (final String p_grantId, final String p_clientId)
void	prepareGrantBranch (final String p_grantId, final String p_clientId)
boolean	containsGrantBranch (final String p_grantId, final String p_clientId)
String	getBaseDnForGrant (final String p_grantId, final String p_clientId)
void	auditLogging (Collection< TokenLdap > entries)

非公開変数類
Logger	log
PersistenceEntryManager	ldapEntryManager
ApplicationAuditLogger	applicationAuditLogger
ClientService	clientService
CacheService	cacheService
StaticConfiguration	staticConfiguration
AppConfiguration	appConfiguration

詳解

著者

Yuriy Zabrovarnyy

Javier Rojas Blum

バージョン

November 11, 2016

関数詳解

addGrantBranch()

void org.xdi.oxauth.service.GrantService.addGrantBranch ( final String  p_grantId, final String  p_clientId  )

inlineprivate

                                                                                 {
        Grant grant = new Grant();
        grant.setDn(getBaseDnForGrant(p_grantId, p_clientId));
        grant.setId(p_grantId);
        grant.setCreationDate(new Date());

        ldapEntryManager.persist(grant);
    }

auditLogging()

void org.xdi.oxauth.service.GrantService.auditLogging ( Collection< TokenLdap >  entries )

inlineprivate

                                                             {
        for (TokenLdap tokenLdap : entries) {
            OAuth2AuditLog oAuth2AuditLog = new OAuth2AuditLog(null, Action.SESSION_DESTROYED);
            oAuth2AuditLog.setSuccess(true);
            oAuth2AuditLog.setClientId(tokenLdap.getClientId());
            oAuth2AuditLog.setScope(tokenLdap.getScope());
            oAuth2AuditLog.setUsername(tokenLdap.getUserId());
            applicationAuditLogger.sendMessage(oAuth2AuditLog);
        }
    }

baseDn()

String org.xdi.oxauth.service.GrantService.baseDn ( )

inline

                           {
        return staticConfiguration.getBaseDn().getClients();  // ou=clients,o=@!1111,o=gluu
    }

buildDn()

String org.xdi.oxauth.service.GrantService.buildDn ( String  p_uniqueIdentifier, String  p_grantId, String  p_clientId  )

inline

                                                                                          {
        final StringBuilder dn = new StringBuilder();
        dn.append(String.format("uniqueIdentifier=%s,oxAuthGrantId=%s,", p_uniqueIdentifier, p_grantId));
        dn.append(clientService.buildClientDn(p_clientId));
        return dn.toString();
    }

cleanUp()

void org.xdi.oxauth.service.GrantService.cleanUp ( )

inline

                          {
        // Cleaning oxAuthToken
        BatchOperation<TokenLdap> tokenBatchService = new ProcessBatchOperation<TokenLdap>() {
            @Override
                public void performAction(List<TokenLdap> entries) {
                auditLogging(entries);
                remove(entries);
            }
        };
        ldapEntryManager.findEntries(baseDn(), TokenLdap.class, getExpiredTokenFilter(), SearchScope.SUB, new String[] { "oxAuthTokenCode", "oxAuthClientId", "oxAuthScope", "oxAuthUserId" }, tokenBatchService, 0, 0, CleanerTimer.BATCH_SIZE);

        // Cleaning oxAuthGrant
        BatchOperation<Grant> grantBatchService = new ProcessBatchOperation<Grant>() {
            @Override
            public void performAction(List<Grant> entries) {
                removeGrants(entries);
            }

        };
        ldapEntryManager.findEntries(baseDn(), Grant.class, getExpiredGrantFilter(), SearchScope.SUB, new String[] { "" }, grantBatchService, 0, 0, CleanerTimer.BATCH_SIZE);

        // Cleaning old oxAuthGrant
        // Note: This block should be removed, it is used only to delete old legacy data.
        BatchOperation<Grant> oldGrantBatchService = new ProcessBatchOperation<Grant>() {
            @Override
            public void performAction(List<Grant> entries) {
                removeGrants(entries);
            }
        };
        ldapEntryManager.findEntries(baseDn(), Grant.class, getExpiredOldGrantFilter(), SearchScope.SUB, new String[] { "" }, oldGrantBatchService, 0, 0, CleanerTimer.BATCH_SIZE);
    }

containsGrantBranch()

boolean org.xdi.oxauth.service.GrantService.containsGrantBranch ( final String  p_grantId, final String  p_clientId  )

inlineprivate

                                                                                         {
        return ldapEntryManager.contains(Grant.class, getBaseDnForGrant(p_grantId, p_clientId));
    }

generateGrantId()

static String org.xdi.oxauth.service.GrantService.generateGrantId ( )

inlinestatic

                                           {
        return UUID.randomUUID().toString();
    }

getBaseDnForGrant()

String org.xdi.oxauth.service.GrantService.getBaseDnForGrant ( final String  p_grantId, final String  p_clientId  )

inlineprivate

                                                                                      {
        final StringBuilder dn = new StringBuilder();
        dn.append(String.format("oxAuthGrantId=%s,", p_grantId));
        dn.append(clientService.buildClientDn(p_clientId));

        return dn.toString();
    }

getCacheClientTokens()

ClientTokens org.xdi.oxauth.service.GrantService.getCacheClientTokens ( String  clientId )

inline

                                                              {
        ClientTokens clientTokens = new ClientTokens(clientId);
        Object o = cacheService.get(null, clientTokens.cacheKey());
        if (o instanceof ClientTokens) {
            return (ClientTokens) o;
        } else {
            return clientTokens;
        }
    }

getCacheClientTokensEntries()

List<TokenLdap> org.xdi.oxauth.service.GrantService.getCacheClientTokensEntries ( String  clientId )

inline

                                                                        {
        Object o = cacheService.get(null, new ClientTokens(clientId).cacheKey());
        if (o instanceof ClientTokens) {
            return getCacheTokensEntries(((ClientTokens) o).getTokenHashes());
        }
        return Collections.emptyList();
    }

getCacheSessionTokens()

SessionTokens org.xdi.oxauth.service.GrantService.getCacheSessionTokens ( String  sessionDn )

inline

                                                                 {
        SessionTokens sessionTokens = new SessionTokens(sessionDn);
        Object o = cacheService.get(null, sessionTokens.cacheKey());
        if (o instanceof SessionTokens) {
            return (SessionTokens) o;
        } else {
            return sessionTokens;
        }
    }

getCacheTokensEntries()

List<TokenLdap> org.xdi.oxauth.service.GrantService.getCacheTokensEntries ( Set< String >  tokenHashes )

inline

                                                                          {
        List<TokenLdap> tokens = new ArrayList<TokenLdap>();

        for (String tokenHash : tokenHashes) {
            Object o1 = cacheService.get(null, tokenHash);
            if (o1 instanceof TokenLdap) {
                TokenLdap token = (TokenLdap) o1;
                token.setIsFromCache(true);
                tokens.add(token);
            }
        }
        return tokens;
    }

getExpiredGrantFilter()

Filter org.xdi.oxauth.service.GrantService.getExpiredGrantFilter ( )

inlineprivate

                                           {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND, 60);

        Filter hasSubordinates = Filter.createORFilter(Filter.createEqualityFilter("numsubordinates", "0"),
                        Filter.createEqualityFilter("hasSubordinates", "FALSE")); 
        Filter creationDate = Filter.createLessOrEqualFilter("oxAuthCreation", ldapEntryManager.encodeTime(calendar.getTime()));
        Filter filter = Filter.createANDFilter(creationDate, hasSubordinates);
        
        return filter;
    }

getExpiredOldGrantFilter()

Filter org.xdi.oxauth.service.GrantService.getExpiredOldGrantFilter ( )

inlineprivate

                                              {
        Filter hasSubordinatesFilter = Filter.createORFilter(Filter.createEqualityFilter("numsubordinates", "0"),
                        Filter.createEqualityFilter("hasSubordinates", "FALSE")); 
        Filter noCreationDate = Filter.createNOTFilter(Filter.createPresenceFilter("oxAuthCreation"));
        Filter filter = Filter.createANDFilter(noCreationDate, hasSubordinatesFilter);
        
        return filter;
    }

getExpiredTokenFilter()

Filter org.xdi.oxauth.service.GrantService.getExpiredTokenFilter ( )

inlineprivate

                                           {
        return Filter.createLessOrEqualFilter("oxAuthExpiration", ldapEntryManager.encodeTime(new Date()));
    }

getGrantsByAuthorizationCode()

List<TokenLdap> org.xdi.oxauth.service.GrantService.getGrantsByAuthorizationCode ( String  p_authorizationCode )

inline

                                                                                    {
        try {
            return ldapEntryManager.findEntries(baseDn(), TokenLdap.class, Filter.createEqualityFilter("oxAuthAuthorizationCode", TokenHashUtil.getHashedToken(p_authorizationCode)));
        } catch (Exception e) {
            log.trace(e.getMessage(), e);
        }
        return Collections.emptyList();
    }

getGrantsByCode() [1/2]

TokenLdap org.xdi.oxauth.service.GrantService.getGrantsByCode ( String  p_code )

inline

                                                    {
        return getGrantsByCode(p_code, false);
    }

getGrantsByCode() [2/2]

TokenLdap org.xdi.oxauth.service.GrantService.getGrantsByCode ( String  p_code, boolean  onlyFromCache  )

inline

                                                                           {
        Object grant = cacheService.get(null, TokenHashUtil.getHashedToken(p_code));
        if (grant instanceof TokenLdap) {
            return (TokenLdap) grant;
        } else {
            if (onlyFromCache) {
                return null;
            }
            return load(baseDn(), p_code);
        }
    }

getGrantsByCodeAndClient()

TokenLdap org.xdi.oxauth.service.GrantService.getGrantsByCodeAndClient ( String  p_code, String  p_clientId  )

inline

                                                                                {
        return load(clientService.buildClientDn(p_clientId), p_code);
    }

getGrantsByGrantId()

List<TokenLdap> org.xdi.oxauth.service.GrantService.getGrantsByGrantId ( String  p_grantId )

inline

                                                                {
        try {
            return ldapEntryManager.findEntries(baseDn(), TokenLdap.class, Filter.createEqualityFilter("oxAuthGrantId", p_grantId));
        } catch (Exception e) {
            log.trace(e.getMessage(), e);
        }
        return Collections.emptyList();
    }

getGrantsBySessionDn()

List<TokenLdap> org.xdi.oxauth.service.GrantService.getGrantsBySessionDn ( String  sessionDn )

inline

                                                                  {
        List<TokenLdap> grants = new ArrayList<TokenLdap>();
        try {
            List<TokenLdap> ldapGrants = ldapEntryManager.findEntries(baseDn(), TokenLdap.class, Filter.create(String.format("oxAuthSessionDn=%s", sessionDn)));
            if (ldapGrants != null) {
                grants.addAll(ldapGrants);
            }
            grants.addAll(getGrantsFromCacheBySessionDn(sessionDn));
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return grants;
    }

getGrantsFromCacheBySessionDn()

List<TokenLdap> org.xdi.oxauth.service.GrantService.getGrantsFromCacheBySessionDn ( String  sessionDn )

inline

                                                                           {
        if (StringUtils.isBlank(sessionDn)) {
            return Collections.emptyList();
        }
        return getCacheTokensEntries(getCacheSessionTokens(sessionDn).getTokenHashes());
    }

getGrantsOfClient()

List<TokenLdap> org.xdi.oxauth.service.GrantService.getGrantsOfClient ( String  p_clientId )

inline

                                                                {
        try {
            final String baseDn = clientService.buildClientDn(p_clientId);
            return ldapEntryManager.findEntries(baseDn, TokenLdap.class, Filter.create("oxAuthTokenCode=*"));
        } catch (Exception e) {
            log.trace(e.getMessage(), e);
        }
        return Collections.emptyList();
    }

load()

TokenLdap org.xdi.oxauth.service.GrantService.load ( String  p_baseDn, String  p_code  )

inlineprivate

                                                           {
        try {
            final List<TokenLdap> entries = ldapEntryManager.findEntries(p_baseDn, TokenLdap.class, Filter.createEqualityFilter("oxAuthTokenCode", TokenHashUtil.getHashedToken(p_code)));
            if (entries != null && !entries.isEmpty()) {
                return entries.get(0);
            }
        } catch (Exception e) {
            log.trace(e.getMessage(), e);
        }
        return null;
    }

merge()

void org.xdi.oxauth.service.GrantService.merge ( TokenLdap  p_token )

inline

                                         {
        ldapEntryManager.merge(p_token);
    }

mergeSilently()

void org.xdi.oxauth.service.GrantService.mergeSilently ( TokenLdap  p_token )

inline

                                                 {
        try {
            ldapEntryManager.merge(p_token);
        } catch (Exception e) {
            log.trace(e.getMessage(), e);
        }
    }

persist()

void org.xdi.oxauth.service.GrantService.persist ( TokenLdap  token )

inline

                                         {
        String hashedToken = TokenHashUtil.getHashedToken(token.getTokenCode());
        token.setTokenCode(hashedToken);

        if (shouldPutInCache(token.getTokenTypeEnum(), token.isImplicitFlow())) {
            ClientTokens clientTokens = getCacheClientTokens(token.getClientId());
            clientTokens.getTokenHashes().add(hashedToken);

            String expiration = null;
            switch (token.getTokenTypeEnum()) {
                case ID_TOKEN:
                    expiration = Integer.toString(appConfiguration.getIdTokenLifetime());
                    break;
                case REFRESH_TOKEN:
                    expiration = Integer.toString(appConfiguration.getRefreshTokenLifetime());
                    break;
                case ACCESS_TOKEN:
                    expiration = Integer.toString(appConfiguration.getAccessTokenLifetime());
                    break;
            }

            token.setIsFromCache(true);
            cacheService.put(expiration, hashedToken, token);
            cacheService.put(expiration, clientTokens.cacheKey(), clientTokens);

            if (StringUtils.isNotBlank(token.getSessionDn())) {
                SessionTokens sessionTokens = getCacheSessionTokens(token.getSessionDn());
                sessionTokens.getTokenHashes().add(hashedToken);

                cacheService.put(expiration, sessionTokens.cacheKey(), sessionTokens);
            }
            return;
        }

        prepareGrantBranch(token.getGrantId(), token.getClientId());
        ldapEntryManager.persist(token);
    }

prepareGrantBranch()

void org.xdi.oxauth.service.GrantService.prepareGrantBranch ( final String  p_grantId, final String  p_clientId  )

inlineprivate

                                                                                     {
        // Create ocAuthGrant branch if needed
        if (!containsGrantBranch(p_grantId, p_clientId)) {
            addGrantBranch(p_grantId, p_clientId);
        }
    }

remove() [1/4]

void org.xdi.oxauth.service.GrantService.remove ( Grant  grant )

inline

                                    {
        ldapEntryManager.remove(grant);
        log.trace("Removed grant, id: " + grant.getId());
    }

remove() [2/4]

void org.xdi.oxauth.service.GrantService.remove ( TokenLdap  p_token )

inline

                                          {
        if (p_token.isFromCache()) {
            cacheService.remove(null, TokenHashUtil.getHashedToken(p_token.getTokenCode()));
            log.trace("Removed token from cache, code: " + p_token.getTokenCode());
        } else {
            ldapEntryManager.remove(p_token);
            log.trace("Removed token from LDAP, code: " + p_token.getTokenCode());
        }
    }

remove() [3/4]

void org.xdi.oxauth.service.GrantService.remove ( List< TokenLdap >  p_entries )

inline

                                                  {
        if (p_entries != null && !p_entries.isEmpty()) {
            for (TokenLdap t : p_entries) {
                try {
                    remove(t);
                } catch (Exception e) {
                    log.error("Failed to remove entry", e);
                }
            }
        }
    }

remove() [4/4]

void org.xdi.oxauth.service.GrantService.remove ( AuthorizationGrant  p_grant )

inline

                                                   {
        if (p_grant != null && p_grant.getTokenLdap() != null) {
            try {
                remove(p_grant.getTokenLdap());
            } catch (Exception e) {
                log.trace(e.getMessage(), e);
            }
        }
    }

removeAllByAuthorizationCode()

void org.xdi.oxauth.service.GrantService.removeAllByAuthorizationCode ( String  p_authorizationCode )

inline

                                                                         {
        removeSilently(getGrantsByAuthorizationCode(p_authorizationCode));
    }

removeAllByGrantId()

void org.xdi.oxauth.service.GrantService.removeAllByGrantId ( String  p_grantId )

inline

                                                     {
        removeSilently(getGrantsByGrantId(p_grantId));
    }

removeAllTokensBySession()

void org.xdi.oxauth.service.GrantService.removeAllTokensBySession ( String  sessionDn )

inline

                                                           {
        removeSilently(getGrantsBySessionDn(sessionDn));
    }

removeByCode()

void org.xdi.oxauth.service.GrantService.removeByCode ( String  p_code, String  p_clientId  )

inline

Removes grant with particular code.

引数

p_code

code

                                                               {
        final TokenLdap t = getGrantsByCodeAndClient(p_code, p_clientId);
        if (t != null) {
            removeSilently(t);
        }
        cacheService.remove(null, CacheGrant.cacheKey(p_clientId, p_code, null));
    }

removeGrants()

void org.xdi.oxauth.service.GrantService.removeGrants ( List< Grant >  entries )

inline

                                                  {
        if (entries != null && !entries.isEmpty()) {
            for (Grant g : entries) {
                try {
                    remove(g);
                } catch (Exception e) {
                    log.error("Failed to remove entry", e);
                }
            }
        }
    }

removeSilently() [1/2]

void org.xdi.oxauth.service.GrantService.removeSilently ( TokenLdap  token )

inline

                                                {
        try {
            remove(token);

            if (StringUtils.isNotBlank(token.getAuthorizationCode())) {
                cacheService.remove(null, CacheGrant.cacheKey(token.getClientId(), token.getAuthorizationCode(), token.getGrantId()));
            }
        } catch (Exception e) {
            log.trace(e.getMessage(), e);
        }
    }

removeSilently() [2/2]

void org.xdi.oxauth.service.GrantService.removeSilently ( List< TokenLdap >  p_entries )

inline

                                                          {
        if (p_entries != null && !p_entries.isEmpty()) {
            for (TokenLdap t : p_entries) {
                removeSilently(t);
            }
        }
    }

shouldPutInCache()

boolean org.xdi.oxauth.service.GrantService.shouldPutInCache ( TokenType  tokenType, boolean  isImplicitFlow  )

inlineprivate

                                                                                  {
        if (isImplicitFlow && BooleanUtils.isTrue(appConfiguration.getUseCacheForAllImplicitFlowObjects())) {
            return true;
        }

        switch (tokenType) {
            case ID_TOKEN:
                if (!isTrue(appConfiguration.getPersistIdTokenInLdap())) {
                    return true;
                }
            case REFRESH_TOKEN:
                if (!isTrue(appConfiguration.getPersistRefreshTokenInLdap())) {
                    return true;
                }
        }
        return false;
    }

メンバ詳解

appConfiguration

AppConfiguration org.xdi.oxauth.service.GrantService.appConfiguration

private

applicationAuditLogger

ApplicationAuditLogger org.xdi.oxauth.service.GrantService.applicationAuditLogger

private

cacheService

CacheService org.xdi.oxauth.service.GrantService.cacheService

private

clientService

ClientService org.xdi.oxauth.service.GrantService.clientService

private

ldapEntryManager

PersistenceEntryManager org.xdi.oxauth.service.GrantService.ldapEntryManager

private

log

Logger org.xdi.oxauth.service.GrantService.log

private

staticConfiguration

StaticConfiguration org.xdi.oxauth.service.GrantService.staticConfiguration

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxAuth/Server/src/main/java/org/xdi/oxauth/service/GrantService.java