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

org.xdi.oxauth.service.BaseAuthFilterService の継承関係図

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

クラス
class	AuthenticationFilterWithParameters
class	IndexedParameter

公開メンバ関数
void	init (List<? extends BaseFilter > p_filterList, boolean p_enabled, boolean p_filterAttributes)
String	loadEntryDN (PersistenceEntryManager p_manager, AuthenticationFilterWithParameters authenticationFilterWithParameters, Map< String, String > normalizedAttributeValues)
String	processAuthenticationFilters (Map<?, ?> attributeValues)
abstract String	processAuthenticationFilter (AuthenticationFilterWithParameters p_allowed, Map<?, ?> p_attributeValues)
List< AuthenticationFilterWithParameters >	getFilterWithParameters ()
boolean	isEnabled ()
void	setEnabled (boolean p_enabled)
boolean	isFilterAttributes ()
void	setFilterAttributes (boolean p_filterAttributes)

静的公開メンバ関数
static List< AuthenticationFilterWithParameters >	getAllowedAuthenticationFilters (Collection<?> attributeNames, List< AuthenticationFilterWithParameters > p_filterList)
static Map< String, String >	normalizeAttributeMap (Map<?, ?> attributeValues)
static String	buildFilter (AuthenticationFilterWithParameters authenticationFilterWithParameters, Map< String, String > p_normalizedAttributeValues)
static String	normalizeAttributeName (String attributeName)

静的公開変数類
static final Pattern	PARAM_VALUE_PATTERN = Pattern.compile("([\\w]+)[\\s]*\\=[\\*\\s]*(\\{[\\s]*[\\d]+[\\s]*\\})[\\*\\s]*")

限定公開変数類
Logger	log

非公開メンバ関数
List< AuthenticationFilterWithParameters >	prepareAuthenticationFilterWithParameters (List<? extends BaseFilter > p_filterList)

非公開変数類
boolean	enabled
boolean	filterAttributes = true
List< AuthenticationFilterWithParameters >	filterWithParameters

詳解

著者

Yuriy Movchan

Yuriy Zabrovarnyy

Javier Rojas Blum

バージョン

March 4, 2016

関数詳解

buildFilter()

static String org.xdi.oxauth.service.BaseAuthFilterService.buildFilter ( AuthenticationFilterWithParameters  authenticationFilterWithParameters, Map< String, String >  p_normalizedAttributeValues  )

inlinestatic

                                                                                                                                                             {
        String filter = authenticationFilterWithParameters.getAuthenticationFilter().getFilter();
        for (IndexedParameter indexedParameter : authenticationFilterWithParameters.getIndexedVariables()) {
            String attributeValue = p_normalizedAttributeValues.get(indexedParameter.getParamName());
            if (attributeValue != null) {
                filter = filter.replace(indexedParameter.getParamIndex(), attributeValue);
            }
        }
        return filter;
    }

getAllowedAuthenticationFilters()

static List<AuthenticationFilterWithParameters> org.xdi.oxauth.service.BaseAuthFilterService.getAllowedAuthenticationFilters ( Collection<?>  attributeNames, List< AuthenticationFilterWithParameters >  p_filterList  )

inlinestatic

                                                                                                                                                                                {
        List<AuthenticationFilterWithParameters> tmpAuthenticationFilterWithParameters = new ArrayList<AuthenticationFilterWithParameters>();
        if (attributeNames == null) {
            return tmpAuthenticationFilterWithParameters;
        }

        Set<String> normalizedAttributeNames = new HashSet<String>();
        for (Object attributeName : attributeNames) {
            normalizedAttributeNames.add(normalizeAttributeName(attributeName.toString()));
        }

        for (AuthenticationFilterWithParameters autheticationFilterWithParameters : p_filterList) {
            if (normalizedAttributeNames.containsAll(autheticationFilterWithParameters.getVariableNames())) {
                tmpAuthenticationFilterWithParameters.add(autheticationFilterWithParameters);
            }
        }

        return tmpAuthenticationFilterWithParameters;
    }

getFilterWithParameters()

List<AuthenticationFilterWithParameters> org.xdi.oxauth.service.BaseAuthFilterService.getFilterWithParameters ( )

inline

                                                                              {
        return filterWithParameters;
    }

init()

void org.xdi.oxauth.service.BaseAuthFilterService.init ( List<? extends BaseFilter >  p_filterList, boolean  p_enabled, boolean  p_filterAttributes  )

inline

                                                                                                             {
        this.enabled = p_enabled;
        this.filterWithParameters = prepareAuthenticationFilterWithParameters(p_filterList);
        this.filterAttributes = p_filterAttributes;
    }

isEnabled()

boolean org.xdi.oxauth.service.BaseAuthFilterService.isEnabled ( )

inline

                               {
        return enabled;
    }

isFilterAttributes()

boolean org.xdi.oxauth.service.BaseAuthFilterService.isFilterAttributes ( )

inline

                                        {
        return filterAttributes;
    }

loadEntryDN()

String org.xdi.oxauth.service.BaseAuthFilterService.loadEntryDN ( PersistenceEntryManager  p_manager, AuthenticationFilterWithParameters  authenticationFilterWithParameters, Map< String, String >  normalizedAttributeValues  )

inline

                                                                                                                                                                                       {
        final String filter = buildFilter(authenticationFilterWithParameters, normalizedAttributeValues);

        Filter ldapFilter = Filter.create(filter);
        List<DummyEntry> foundEntries = p_manager.findEntries(authenticationFilterWithParameters.getAuthenticationFilter().getBaseDn(), DummyEntry.class, ldapFilter, new String[0]);

        if (foundEntries.size() > 1) {
            log.error("Found more than one entry by filter: '{}'. Entries:\n", ldapFilter, foundEntries);
            return null;
        }

        if (!(foundEntries.size() == 1)) {
            return null;
        }

        return foundEntries.get(0).getDn();
    }

normalizeAttributeMap()

static Map<String, String> org.xdi.oxauth.service.BaseAuthFilterService.normalizeAttributeMap ( Map<?, ?>  attributeValues )

inlinestatic

                                                                                       {
        Map<String, String> normalizedAttributeValues = new HashMap<String, String>();
        for (Map.Entry<?, ?> attributeValueEntry : attributeValues.entrySet()) {
            String attributeValue = null;

            Object attributeValueEntryValue = attributeValueEntry.getValue();
            if (attributeValueEntryValue instanceof String[]) {
                if (ArrayHelper.isNotEmpty((String[]) attributeValueEntryValue)) {
                    attributeValue = ((String[]) attributeValueEntryValue)[0];
                }
            } else if (attributeValueEntryValue instanceof String) {
                attributeValue = (String) attributeValueEntryValue;
            } else if (attributeValueEntryValue != null) {
                attributeValue = attributeValueEntryValue.toString();
            }

            if (attributeValue != null) {
                normalizedAttributeValues.put(normalizeAttributeName(attributeValueEntry.getKey().toString()), attributeValue);
            }
        }
        return normalizedAttributeValues;
    }

normalizeAttributeName()

static String org.xdi.oxauth.service.BaseAuthFilterService.normalizeAttributeName ( String  attributeName )

inlinestatic

                                                                      {
        return StringHelper.toLowerCase(attributeName.trim());
    }

prepareAuthenticationFilterWithParameters()

List<AuthenticationFilterWithParameters> org.xdi.oxauth.service.BaseAuthFilterService.prepareAuthenticationFilterWithParameters ( List<? extends BaseFilter >  p_filterList )

inlineprivate

                                                                                                                                        {
        final List<AuthenticationFilterWithParameters> tmpAuthenticationFilterWithParameters = new ArrayList<AuthenticationFilterWithParameters>();

        if (!this.enabled || p_filterList == null) {
            return tmpAuthenticationFilterWithParameters;
        }

        for (BaseFilter authenticationFilter : p_filterList) {
            if (Boolean.TRUE.equals(authenticationFilter.getBind()) && StringHelper.isEmpty(authenticationFilter.getBindPasswordAttribute())) {
                log.error("Skipping authentication filter:\n '{}'\n. It should contains not empty bind-password-attribute attribute. ", authenticationFilter);
                continue;
            }

            List<String> variableNames = new ArrayList<String>();
            List<BaseAuthFilterService.IndexedParameter> indexedParameters = new ArrayList<BaseAuthFilterService.IndexedParameter>();

            Matcher matcher = BaseAuthFilterService.PARAM_VALUE_PATTERN.matcher(authenticationFilter.getFilter());
            while (matcher.find()) {
                String paramName = normalizeAttributeName(matcher.group(1));
                String paramIndex = matcher.group(2);

                variableNames.add(paramName);
                indexedParameters.add(new BaseAuthFilterService.IndexedParameter(paramName, paramIndex));
            }

            AuthenticationFilterWithParameters tmpAutheticationFilterWithParameter = new AuthenticationFilterWithParameters(authenticationFilter, variableNames, indexedParameters);
            tmpAuthenticationFilterWithParameters.add(tmpAutheticationFilterWithParameter);

            log.debug("Authentication filter with parameters: '{}'. ", tmpAutheticationFilterWithParameter);
        }

        return tmpAuthenticationFilterWithParameters;
    }

processAuthenticationFilter()

abstract String org.xdi.oxauth.service.BaseAuthFilterService.processAuthenticationFilter ( AuthenticationFilterWithParameters  p_allowed, Map<?, ?>  p_attributeValues  )

abstract

processAuthenticationFilters()

String org.xdi.oxauth.service.BaseAuthFilterService.processAuthenticationFilters ( Map<?, ?>  attributeValues )

inline

                                                                          {
        if (attributeValues == null) {
            return null;
        }

        final List<AuthenticationFilterWithParameters> allowedList = filterAttributes ?
                getAllowedAuthenticationFilters(attributeValues.keySet(), getFilterWithParameters()) :
                getFilterWithParameters();

        for (AuthenticationFilterWithParameters allowed : allowedList) {
            String resultDn = processAuthenticationFilter(allowed, attributeValues);
            if (StringHelper.isNotEmpty(resultDn)) {
                return resultDn;
            }
        }

        return null;
    }

setEnabled()

void org.xdi.oxauth.service.BaseAuthFilterService.setEnabled ( boolean  p_enabled )

inline

                                              {
        enabled = p_enabled;
    }

setFilterAttributes()

void org.xdi.oxauth.service.BaseAuthFilterService.setFilterAttributes ( boolean  p_filterAttributes )

inline

                                                                {
        filterAttributes = p_filterAttributes;
    }

メンバ詳解

enabled

boolean org.xdi.oxauth.service.BaseAuthFilterService.enabled

private

filterAttributes

boolean org.xdi.oxauth.service.BaseAuthFilterService.filterAttributes = true

private

filterWithParameters

List<AuthenticationFilterWithParameters> org.xdi.oxauth.service.BaseAuthFilterService.filterWithParameters

private

log

Logger org.xdi.oxauth.service.BaseAuthFilterService.log

protected

PARAM_VALUE_PATTERN

final Pattern org.xdi.oxauth.service.BaseAuthFilterService.PARAM_VALUE_PATTERN = Pattern.compile("([\\w]+)[\\s]*\\=[\\*\\s]*(\\{[\\s]*[\\d]+[\\s]*\\})[\\*\\s]*")

static

---

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

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