Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -49,6 +49,7 @@ public class InfinispanOrganizationProvider implements OrganizationProvider {

private static final String ORG_COUNT_KEY_SUFFIX = ".org.count";
private static final String ORG_EXISTS_KEY_SUFFIX = ".org.exists";
private static final String ORG_DISABLED_EXISTS_KEY_SUFFIX = ".org.disabled.exists";
private static final String ORG_MEMBERS_COUNT_KEY_SUFFIX = ".members.count";

private final KeycloakSession session;
Expand All @@ -73,6 +74,10 @@ private static String cacheKeyOrgExists(RealmModel realm) {
return realm.getId() + ORG_EXISTS_KEY_SUFFIX;
}

public static String cacheKeyOrgDisabledExists(RealmModel realm) {
return realm.getId() + ORG_DISABLED_EXISTS_KEY_SUFFIX;
}

public static String cacheKeyOrgMemberCount(RealmModel realm, OrganizationModel organization) {
return realm.getId() + ".org." + organization.getId() + ORG_MEMBERS_COUNT_KEY_SUFFIX;
}
Expand Down Expand Up @@ -542,6 +547,8 @@ void registerOrganizationInvalidation(OrganizationModel organization) {

if (realmCache != null) {
realmCache.registerInvalidation(cacheKeyOrgId(getRealm(), id));
// the organization may have been enabled or disabled
realmCache.registerInvalidation(cacheKeyOrgDisabledExists(getRealm()));
realmCache.registerInvalidation(id);
CachedOrganization cachedOrg = realmCache.getCache().get(id, CachedOrganization.class);

Expand Down Expand Up @@ -584,6 +591,7 @@ private void registerCountInvalidation() {
if (realmCache != null) {
realmCache.registerInvalidation(cacheKeyOrgCount(getRealm()));
realmCache.registerInvalidation(cacheKeyOrgExists(getRealm()));
realmCache.registerInvalidation(cacheKeyOrgDisabledExists(getRealm()));
}
}

Expand Down Expand Up @@ -679,4 +687,31 @@ public boolean hasOrganizations() {
realmCache.getCache().addRevisioned(cached, realmCache.getStartupRevision());
return hasOrganizations;
}

@Override
public boolean hasDisabledOrganizations() {
if (realmCache == null) {
return getDelegate().hasDisabledOrganizations();
}

String cacheKey = cacheKeyOrgDisabledExists(getRealm());

// an organization was created, updated or removed in this transaction. The result reflects uncommitted
// changes and must not be visible to other transactions, so it is not cached
if (isRealmCacheKeyInvalid(cacheKey)) {
return getDelegate().hasDisabledOrganizations();
}

CachedExists cached = realmCache.getCache().get(cacheKey, CachedExists.class);

if (cached != null) {
return cached.isExists();
}

Long loaded = realmCache.getCache().getCurrentRevision(cacheKey);
boolean hasDisabledOrganizations = getDelegate().hasDisabledOrganizations();
cached = new CachedExists(loaded, getRealm(), cacheKey, hasDisabledOrganizations);
realmCache.getCache().addRevisioned(cached, realmCache.getStartupRevision());
return hasDisabledOrganizations;
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -46,6 +46,7 @@
@NamedQuery(name="getCount", query="select count(o) from OrganizationEntity o where o.realmId = :realmId"),
@NamedQuery(name="deleteOrganizationsByRealm", query="delete from OrganizationEntity o where o.realmId = :realmId"),
@NamedQuery(name="existsByRealm", query="select o.id from OrganizationEntity o where o.realmId = :realmId"),
@NamedQuery(name="existsDisabledByRealm", query="select o.id from OrganizationEntity o where o.realmId = :realmId and o.enabled = false"),
})
public class OrganizationEntity {

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -1172,4 +1172,13 @@ public boolean hasOrganizations() {

return !query.getResultList().isEmpty();
}

@Override
public boolean hasDisabledOrganizations() {
TypedQuery<String> query = em.createNamedQuery("existsDisabledByRealm", String.class);
query.setParameter("realmId", getRealm().getId());
query.setMaxResults(1);

return !query.getResultList().isEmpty();
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -1285,10 +1285,20 @@ private boolean isReadOnlyOrganizationMember(UserModel delegate) {

// disable FGAP filtering for this system-level check to avoid infinite recursion:
// getByMember -> applyAuthorizationFilters -> getPredicates -> getUser -> getUserById -> validateUser -> isReadOnlyOrganizationMember -> ...
return AdminPermissionsSchema.runWithoutAuthorization(session, () ->
organizationProvider.getByMember(delegate)
.anyMatch((org) -> (organizationProvider.isEnabled() && org.isManaged(delegate) && !org.isEnabled()) ||
(!organizationProvider.isEnabled() && org.isManaged(delegate))));
return AdminPermissionsSchema.runWithoutAuthorization(session, () -> {
boolean organizationsEnabled = organizationProvider.isEnabled();

// a member is read-only only if managed by a disabled organization, so there is no need to check
// the memberships of the user if organizations are enabled and none of them is disabled
if (organizationsEnabled && !organizationProvider.hasDisabledOrganizations()) {
return false;
}

// user is a managed member of a disabled organization OR organizations are disabled and user is a managed member.
// check the (cached) enabled state of the organization before the more expensive managed membership check
return organizationProvider.getByMember(delegate)
.anyMatch((org) -> (!organizationsEnabled || !org.isEnabled()) && org.isManaged(delegate));
});
}

private void publishUserPreRemovedEvent(RealmModel realm, UserModel user) {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -528,4 +528,13 @@ default boolean isMember(OrganizationModel organization, UserModel user) {
default boolean hasOrganizations() {
return count() > 0;
}

/**
* Used to provide an optimized check if any disabled organization exists in the realm.
*
* @return true if at least one organization in the realm is disabled
*/
default boolean hasDisabledOrganizations() {
return getAllStream().anyMatch(organization -> !organization.isEnabled());
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -564,10 +564,20 @@ public static boolean isReadOnlyOrganizationMember(KeycloakSession session, User

// disable FGAP filtering for this system-level check to avoid infinite recursion:
// getByMember -> applyAuthorizationFilters -> getPredicates -> getUser -> getUserById -> validateUser -> isReadOnlyOrganizationMember -> ...
return AdminPermissionsSchema.runWithoutAuthorization(session, () ->
organizationProvider.getByMember(delegate)
.anyMatch((org) -> (organizationProvider.isEnabled() && org.isManaged(delegate) && !org.isEnabled()) ||
(!organizationProvider.isEnabled() && org.isManaged(delegate))));
return AdminPermissionsSchema.runWithoutAuthorization(session, () -> {
boolean organizationsEnabled = organizationProvider.isEnabled();

// a member is read-only only if managed by a disabled organization, so there is no need to check
// the memberships of the user if organizations are enabled and none of them is disabled
if (organizationsEnabled && !organizationProvider.hasDisabledOrganizations()) {
return false;
}

// user is a managed member of a disabled organization OR organizations are disabled and user is a managed member.
// check the (cached) enabled state of the organization before the more expensive managed membership check
return organizationProvider.getByMember(delegate)
.anyMatch((org) -> (!organizationsEnabled || !org.isEnabled()) && org.isManaged(delegate));
});
}

public static OrganizationModel resolveByDomain(List<OrganizationModel> organizations, String domain) {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,7 @@
import org.keycloak.models.UserModel;
import org.keycloak.models.cache.CacheRealmProvider;
import org.keycloak.models.cache.infinispan.CachedCount;
import org.keycloak.models.cache.infinispan.CachedExists;
import org.keycloak.models.cache.infinispan.RealmCacheSession;
import org.keycloak.models.cache.infinispan.idp.IdentityProviderListQuery;
import org.keycloak.models.cache.infinispan.organization.CachedOrganization;
Expand All @@ -55,6 +56,7 @@
import org.keycloak.testframework.remote.runonserver.InjectRunOnServer;
import org.keycloak.testframework.remote.runonserver.RunOnServerClient;
import org.keycloak.tests.organization.admin.AbstractOrganizationTest;
import org.keycloak.tests.suites.DatabaseTest;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
Expand All @@ -63,6 +65,7 @@
import static org.keycloak.models.cache.infinispan.idp.InfinispanIdentityProviderStorageProvider.cacheKeyForLogin;
import static org.keycloak.models.cache.infinispan.idp.InfinispanIdentityProviderStorageProvider.cacheKeyOrgId;
import static org.keycloak.models.cache.infinispan.organization.CachedOrganization.DOMAIN_NAMES_CACHE_MAX_SIZE;
import static org.keycloak.models.cache.infinispan.organization.InfinispanOrganizationProvider.cacheKeyOrgDisabledExists;
import static org.keycloak.models.cache.infinispan.organization.InfinispanOrganizationProvider.cacheKeyOrgMemberCount;

import static org.junit.jupiter.api.Assertions.assertEquals;
Expand Down Expand Up @@ -321,6 +324,113 @@ public void testMembersCount() {
});
}

@Test
@DatabaseTest
public void testHasDisabledOrganizations() {
runOnServer.run(session -> {
OrganizationProvider orgProvider = session.getProvider(OrganizationProvider.class);
RealmModel realm = session.getContext().getRealm();
RealmCacheSession realmCache = (RealmCacheSession) session.getProvider(CacheRealmProvider.class);
String cacheKey = cacheKeyOrgDisabledExists(realm);

assertFalse(orgProvider.hasDisabledOrganizations());
assertFalse(session.getProvider(OrganizationProvider.class, "jpa").hasDisabledOrganizations());
CachedExists cached = realmCache.getCache().get(cacheKey, CachedExists.class);
assertNotNull(cached);
assertFalse(cached.isExists());

orgProvider.getByDomainName("orga.org").setEnabled(false);
});

// disabling an organization invalidates the cached flag
runOnServer.run(session -> {
OrganizationProvider orgProvider = session.getProvider(OrganizationProvider.class);
RealmModel realm = session.getContext().getRealm();
RealmCacheSession realmCache = (RealmCacheSession) session.getProvider(CacheRealmProvider.class);
String cacheKey = cacheKeyOrgDisabledExists(realm);

assertNull(realmCache.getCache().get(cacheKey, CachedExists.class));
assertTrue(orgProvider.hasDisabledOrganizations());
assertTrue(session.getProvider(OrganizationProvider.class, "jpa").hasDisabledOrganizations());
CachedExists cached = realmCache.getCache().get(cacheKey, CachedExists.class);
assertNotNull(cached);
assertTrue(cached.isExists());

orgProvider.getByDomainName("orga.org").setEnabled(true);
});

// enabling an organization invalidates the cached flag
runOnServer.run(session -> {
OrganizationProvider orgProvider = session.getProvider(OrganizationProvider.class);
RealmModel realm = session.getContext().getRealm();
RealmCacheSession realmCache = (RealmCacheSession) session.getProvider(CacheRealmProvider.class);

assertNull(realmCache.getCache().get(cacheKeyOrgDisabledExists(realm), CachedExists.class));
assertFalse(orgProvider.hasDisabledOrganizations());
});

// creating a disabled organization invalidates the cached flag
OrganizationRepresentation orgc = createOrganization("orgc");
orgc.setEnabled(false);
realm.admin().organizations().get(orgc.getId()).update(orgc).close();

runOnServer.run(session -> {
OrganizationProvider orgProvider = session.getProvider(OrganizationProvider.class);
assertTrue(orgProvider.hasDisabledOrganizations());
});

// removing the only disabled organization invalidates the cached flag
realm.admin().organizations().get(orgc.getId()).delete().close();

runOnServer.run(session -> {
OrganizationProvider orgProvider = session.getProvider(OrganizationProvider.class);
RealmModel realm = session.getContext().getRealm();
RealmCacheSession realmCache = (RealmCacheSession) session.getProvider(CacheRealmProvider.class);

assertNull(realmCache.getCache().get(cacheKeyOrgDisabledExists(realm), CachedExists.class));
assertFalse(orgProvider.hasDisabledOrganizations());
});
}

@Test
public void testHasDisabledOrganizationsDoesNotCacheUncommittedChanges() {
// disabling an organization invalidates the cached flag, leaving no entry in the cache
runOnServer.run(session -> {
OrganizationProvider orgProvider = session.getProvider(OrganizationProvider.class);
orgProvider.getByDomainName("orga.org").setEnabled(false);
});

runOnServer.run(session -> {
OrganizationProvider orgProvider = session.getProvider(OrganizationProvider.class);
RealmModel realm = session.getContext().getRealm();
RealmCacheSession realmCache = (RealmCacheSession) session.getProvider(CacheRealmProvider.class);
String cacheKey = cacheKeyOrgDisabledExists(realm);

assertNull(realmCache.getCache().get(cacheKey, CachedExists.class));

// enable the only disabled organization without committing yet
orgProvider.getByDomainName("orga.org").setEnabled(true);

// the current transaction sees its own change
assertFalse(orgProvider.hasDisabledOrganizations());

// but the uncommitted result must not be cached, as other transactions would see it before commit
assertNull(realmCache.getCache().get(cacheKey, CachedExists.class));
});

// once committed, the change is visible and cached
runOnServer.run(session -> {
OrganizationProvider orgProvider = session.getProvider(OrganizationProvider.class);
RealmModel realm = session.getContext().getRealm();
RealmCacheSession realmCache = (RealmCacheSession) session.getProvider(CacheRealmProvider.class);

assertFalse(orgProvider.hasDisabledOrganizations());
CachedExists cached = realmCache.getCache().get(cacheKeyOrgDisabledExists(realm), CachedExists.class);
assertNotNull(cached);
assertFalse(cached.isExists());
});
}

@Test
public void testCacheIDPByOrg() {
IdentityProviderRepresentation idpRep = realm.admin().identityProviders().get("orga-identity-provider").toRepresentation();
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -402,6 +402,89 @@ public void testGetAllDisabledOrganizationProvider() throws IOException {
}
}

@Test
public void testManagedMemberEnabledStateFollowsOrganizationEnabledState() {
OrganizationResource organization = createOrganizationWithBroker(providerRealm, true, MembershipType.MANAGED);
OrganizationRepresentation orgRep = organization.toRepresentation();
addMember(organization, "unmanaged@neworg.org");

// onboard a managed member by authenticating using the organization's provider.
loginViaBroker(aliceFromProviderRealm.getEmail(), aliceFromProviderRealm.getUsername(),
aliceFromProviderRealm.getPassword(), oauth, loginUsernamePage, loginPage, providerRealm);

// no disabled organizations in the realm, all members are enabled
assertManagedMemberEnabled(organization, true);

orgRep.setEnabled(false);
try (Response response = organization.update(orgRep)) {
assertEquals(Status.NO_CONTENT.getStatusCode(), response.getStatus());
}
assertManagedMemberEnabled(organization, false);

// re-enabling the organization must be reflected without stale state from previous lookups
orgRep.setEnabled(true);
try (Response response = organization.update(orgRep)) {
assertEquals(Status.NO_CONTENT.getStatusCode(), response.getStatus());
}
assertManagedMemberEnabled(organization, true);

orgRep.setEnabled(false);
try (Response response = organization.update(orgRep)) {
assertEquals(Status.NO_CONTENT.getStatusCode(), response.getStatus());
}
assertManagedMemberEnabled(organization, false);
}

@Test
public void testManagedMemberEnabledWhenAnotherOrganizationIsDisabled() {
OrganizationResource organization = createOrganizationWithBroker(providerRealm, true, MembershipType.MANAGED);

// onboard a managed member by authenticating using the organization's provider.
loginViaBroker(aliceFromProviderRealm.getEmail(), aliceFromProviderRealm.getUsername(),
aliceFromProviderRealm.getPassword(), oauth, loginUsernamePage, loginPage, providerRealm);
UserRepresentation alice = getUserRepresentation(aliceFromProviderRealm.getEmail());

// the managed member is also an unmanaged member of another organization that gets disabled
OrganizationRepresentation otherRep = createOrganization("other-org");
OrganizationResource other = realm.admin().organizations().get(otherRep.getId());
try (Response response = other.members().addMember(alice.getId())) {
assertEquals(Status.CREATED.getStatusCode(), response.getStatus());
}
MemberRepresentation unmanagedMember = addMember(other, "member@other-org.org");

otherRep.setEnabled(false);
try (Response response = other.update(otherRep)) {
assertEquals(Status.NO_CONTENT.getStatusCode(), response.getStatus());
}

// unmanaged memberships of a disabled organization do not make users read-only
assertThat(realm.admin().users().get(alice.getId()).toRepresentation().isEnabled(), is(true));
assertThat(realm.admin().users().get(unmanagedMember.getId()).toRepresentation().isEnabled(), is(true));
other.members().list(-1, -1).forEach(member -> assertThat(member.getUsername(), member.isEnabled(), is(true)));
organization.members().list(-1, -1).forEach(member -> assertThat(member.getUsername(), member.isEnabled(), is(true)));
}

private void assertManagedMemberEnabled(OrganizationResource organization, boolean expected) {
String managedEmail = aliceFromProviderRealm.getEmail();

List<MemberRepresentation> members = organization.members().list(-1, -1);
assertThat(members, hasSize(2));
for (MemberRepresentation member : members) {
boolean managed = managedEmail.equals(member.getEmail());
assertThat(member.getUsername(), member.isEnabled(), is(!managed || expected));
}

List<UserRepresentation> users = realm.admin().users().search("*neworg*", 0, 10);
assertThat(users, hasSize(2));
for (UserRepresentation user : users) {
boolean managed = managedEmail.equals(user.getEmail());
assertThat(user.getUsername(), user.isEnabled(), is(!managed || expected));
}

UserRepresentation managedUser = getUserRepresentation(managedEmail);
assertThat(realm.admin().users().get(managedUser.getId()).toRepresentation().isEnabled(), is(expected));
}

@Test
public void testDeleteUnmanagedMember() {
UPConfig upConfig = realm.admin().users().userProfile().getConfiguration();
Expand Down