repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LdapRealmConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.EnumSet;
import java.util.Properties;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.configuration.ServerConfigurationSerializer;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.auth.realm.ldap.DirContextFactory;
import org.wildfly.security.auth.realm.ldap.LdapSecurityRealmBuilder;
import org.wildfly.security.auth.realm.ldap.SimpleDirContextFactoryBuilder;
import org.wildfly.security.auth.server.NameRewriter;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityRealm;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @since 10.0
*/
@BuiltBy(LdapRealmConfigurationBuilder.class)
public class LdapRealmConfiguration extends ConfigurationElement<LdapRealmConfiguration> implements RealmProvider {
static final AttributeDefinition<Supplier<CredentialSource>> CREDENTIAL = AttributeDefinition.builder(Attribute.CREDENTIAL, null, (Class<Supplier<CredentialSource>>) (Class<?>) char[].class)
.serializer(ServerConfigurationSerializer.CREDENTIAL)
.immutable()
.build();
static final AttributeDefinition<Boolean> DIRECT_EVIDENCE_VERIFICATION = AttributeDefinition.builder(Attribute.DIRECT_VERIFICATION, null, Boolean.class).immutable().build();
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, "ldap", String.class).immutable().build();
static final AttributeDefinition<NameRewriter> NAME_REWRITER = AttributeDefinition.builder(Element.NAME_REWRITER, null, NameRewriter.class).autoPersist(false).immutable().build();
static final AttributeDefinition<String> PRINCIPAL = AttributeDefinition.builder(Attribute.PRINCIPAL, null, String.class).immutable().build();
static final AttributeDefinition<Integer> PAGE_SIZE = AttributeDefinition.builder(Attribute.PAGE_SIZE, 50, Integer.class).immutable().build();
static final AttributeDefinition<String> URL = AttributeDefinition.builder(Attribute.URL, null, String.class).immutable().build();
static final AttributeDefinition<Integer> CONNECTION_TIMEOUT = AttributeDefinition.builder(Attribute.CONNECTION_TIMEOUT, 5_000, Integer.class).immutable().build();
static final AttributeDefinition<Integer> READ_TIMEOUT = AttributeDefinition.builder(Attribute.READ_TIMEOUT, 60_000, Integer.class).immutable().build();
static final AttributeDefinition<Boolean> CONNECTION_POOLING = AttributeDefinition.builder(Attribute.CONNECTION_POOLING, false, Boolean.class).immutable().build();
static final AttributeDefinition<DirContextFactory.ReferralMode> REFERRAL_MODE = AttributeDefinition.builder(Attribute.REFERRAL_MODE, DirContextFactory.ReferralMode.IGNORE, DirContextFactory.ReferralMode.class).immutable().build();
static final AttributeDefinition<String> CLIENT_SSL_CONTEXT = AttributeDefinition.builder(Attribute.CLIENT_SSL_CONTEXT, null, String.class).immutable().build();
private EnumSet<ServerSecurityRealm.Feature> mappingFeatures = EnumSet.noneOf(ServerSecurityRealm.Feature.class);
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(LdapRealmConfiguration.class, DIRECT_EVIDENCE_VERIFICATION, NAME, NAME_REWRITER, PRINCIPAL, PAGE_SIZE, URL, CONNECTION_TIMEOUT, READ_TIMEOUT, CONNECTION_POOLING, REFERRAL_MODE, CLIENT_SSL_CONTEXT, CREDENTIAL);
}
private final LdapIdentityMappingConfiguration identityMapping;
LdapRealmConfiguration(AttributeSet attributes, LdapIdentityMappingConfiguration identityMapping) {
super(Element.LDAP_REALM, attributes);
this.identityMapping = identityMapping;
}
public LdapIdentityMappingConfiguration identityMapping() {
return identityMapping;
}
@Override
public String name() {
return attributes.attribute(NAME).get();
}
public NameRewriter nameRewriter() {
return attributes.attribute(NAME_REWRITER).get();
}
@Override
public SecurityRealm build(SecurityConfiguration security, RealmConfiguration realm, SecurityDomain.Builder domainBuilder, Properties properties) {
LdapSecurityRealmBuilder ldapRealmBuilder = LdapSecurityRealmBuilder.builder();
attributes.attribute(DIRECT_EVIDENCE_VERIFICATION).apply(ldapRealmBuilder::addDirectEvidenceVerification);
ldapRealmBuilder.setPageSize(attributes.attribute(PAGE_SIZE).get());
mappingFeatures = identityMapping.build(ldapRealmBuilder, realm);
Properties connectionProperties = new Properties();
connectionProperties.setProperty("com.sun.jndi.ldap.connect.pool", attributes.attribute(LdapRealmConfiguration.CONNECTION_POOLING).get().toString());
SimpleDirContextFactoryBuilder dirContextBuilder = SimpleDirContextFactoryBuilder.builder();
dirContextBuilder.setProviderUrl(attributes.attribute(URL).get());
dirContextBuilder.setSecurityPrincipal(attributes.attribute(PRINCIPAL).get());
dirContextBuilder.setCredentialSource(attributes.attribute(CREDENTIAL).get().get());
dirContextBuilder
.setConnectTimeout(attributes.attribute(LdapRealmConfiguration.CONNECTION_TIMEOUT).get())
.setReadTimeout(attributes.attribute(LdapRealmConfiguration.READ_TIMEOUT).get());
dirContextBuilder.setConnectionProperties(connectionProperties);
attributes.attribute(CLIENT_SSL_CONTEXT).apply(v -> dirContextBuilder.setSocketFactory(security.realms().getRealm(v).clientSSLContext().getSocketFactory()));
DirContextFactory dirContextFactory = dirContextBuilder.build();
ldapRealmBuilder.setDirContextSupplier(() -> dirContextFactory.obtainDirContext(attributes.attribute(LdapRealmConfiguration.REFERRAL_MODE).get()));
if (attributes.attribute(LdapRealmConfiguration.NAME_REWRITER).isModified()) {
ldapRealmBuilder.setNameRewriter(attributes.attribute(LdapRealmConfiguration.NAME_REWRITER).get());
}
return ldapRealmBuilder.build();
}
@Override
public void applyFeatures(EnumSet<ServerSecurityRealm.Feature> features) {
features.add(ServerSecurityRealm.Feature.PASSWORD_PLAIN);
features.addAll(mappingFeatures);
}
}
| 6,573
| 64.089109
| 239
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/SecurityConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.Properties;
/**
* @since 10.0
*/
public class SecurityConfiguration {
private final CredentialStoresConfiguration credentialStoresConfiguration;
private final RealmsConfiguration realmsConfiguration;
private final TransportSecurityConfiguration transportConfiguration;
SecurityConfiguration(CredentialStoresConfiguration credentialStoresConfiguration, RealmsConfiguration realmsConfiguration, TransportSecurityConfiguration transportConfiguration, Properties properties) {
this.credentialStoresConfiguration = credentialStoresConfiguration;
this.realmsConfiguration = realmsConfiguration;
this.transportConfiguration = transportConfiguration;
realmsConfiguration.init(this, properties);
}
public CredentialStoresConfiguration credentialStores() {
return credentialStoresConfiguration;
}
public RealmsConfiguration realms() {
return realmsConfiguration;
}
public TransportSecurityConfiguration transport() {
return transportConfiguration;
}
}
| 1,096
| 33.28125
| 206
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/AggregateRealmConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.AggregateRealmConfiguration.AUTHN_REALM;
import static org.infinispan.server.configuration.security.AggregateRealmConfiguration.AUTHZ_REALMS;
import static org.infinispan.server.configuration.security.AggregateRealmConfiguration.NAME_REWRITER;
import static org.infinispan.server.configuration.security.DistributedRealmConfiguration.NAME;
import java.util.Arrays;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.wildfly.security.auth.server.NameRewriter;
/**
* @since 15.0
**/
public class AggregateRealmConfigurationBuilder implements RealmProviderBuilder<AggregateRealmConfiguration> {
private final AttributeSet attributes;
public AggregateRealmConfigurationBuilder() {
this.attributes = AggregateRealmConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public AggregateRealmConfigurationBuilder name(String name) {
attributes.attribute(NAME).set(name);
return this;
}
@Override
public String name() {
return attributes.attribute(NAME).get();
}
public AggregateRealmConfigurationBuilder authnRealm(String realm) {
attributes.attribute(AUTHN_REALM).set(realm);
return this;
}
public AggregateRealmConfigurationBuilder nameRewriter(NameRewriter nameRewriter) {
attributes.attribute(NAME_REWRITER).set(nameRewriter);
return this;
}
public AggregateRealmConfigurationBuilder authzRealms(String[] realms) {
attributes.attribute(AUTHZ_REALMS).set(Arrays.asList(realms));
return this;
}
@Override
public AggregateRealmConfiguration create() {
return new AggregateRealmConfiguration(attributes.protect());
}
@Override
public Builder<?> read(AggregateRealmConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public int compareTo(RealmProviderBuilder o) {
return 1; // Must be the last
}
}
| 2,240
| 30.125
| 110
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/GroupsPropertiesConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.io.File;
import java.util.Properties;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
public class GroupsPropertiesConfiguration extends ConfigurationElement<GroupsPropertiesConfiguration> {
static final AttributeDefinition<String> PATH = AttributeDefinition.builder(Attribute.PATH, null, String.class).build();
static final AttributeDefinition<String> RELATIVE_TO = AttributeDefinition.builder(Attribute.RELATIVE_TO, Server.INFINISPAN_SERVER_CONFIG_PATH, String.class).autoPersist(false).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(GroupsPropertiesConfiguration.class, PATH, RELATIVE_TO);
}
GroupsPropertiesConfiguration(AttributeSet attributes) {
super(Element.GROUP_PROPERTIES, attributes);
}
public String path() {
return attributes.attribute(PATH).get();
}
public String relativeTo() {
return attributes.attribute(RELATIVE_TO).get();
}
public File getFile(Properties properties) {
String path = attributes.attribute(PATH).get();
String relativeTo = properties.getProperty(attributes.attribute(RELATIVE_TO).get());
return new File(ParseUtils.resolvePath(path, relativeTo));
}
}
| 1,643
| 40.1
| 188
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/CredentialStoresConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.configuration.ServerConfigurationBuilder;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class CredentialStoresConfigurationBuilder implements Builder<CredentialStoresConfiguration> {
private final AttributeSet attributes;
private final Map<String, CredentialStoreConfigurationBuilder> credentialStores = new LinkedHashMap<>(2);
private final List<CredentialStoreSourceSupplier> suppliers = new ArrayList<>();
private final ServerConfigurationBuilder builder;
public CredentialStoresConfigurationBuilder(ServerConfigurationBuilder builder) {
this.builder = builder;
this.attributes = CredentialStoresConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public CredentialStoreConfigurationBuilder addCredentialStore(String name) {
CredentialStoreConfigurationBuilder credentialStoreBuilder = new CredentialStoreConfigurationBuilder(name);
credentialStores.put(name, credentialStoreBuilder);
return credentialStoreBuilder;
}
@Override
public CredentialStoresConfiguration create() {
Map<String, CredentialStoreConfiguration> map = credentialStores.entrySet().stream()
.collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue().create()));
CredentialStoresConfiguration configuration = new CredentialStoresConfiguration(attributes.protect(), map, builder.properties());
for (CredentialStoreSourceSupplier s : suppliers) {
s.configuration = configuration;
}
return configuration;
}
@Override
public Builder<?> read(CredentialStoresConfiguration template, Combine combine) {
credentialStores.clear();
template.credentialStores().forEach((k, v) -> addCredentialStore(k).read(v, combine));
return this;
}
public Supplier<CredentialSource> getCredential(String store, String alias) {
CredentialStoreSourceSupplier credentialSupplier = new CredentialStoreSourceSupplier(store, alias);
suppliers.add(credentialSupplier);
return credentialSupplier;
}
public static class CredentialStoreSourceSupplier implements Supplier<CredentialSource> {
final String store;
final String alias;
CredentialStoresConfiguration configuration;
CredentialStoreSourceSupplier(String store, String alias) {
this.store = store;
this.alias = alias;
}
@Override
public CredentialSource get() {
return configuration.getCredentialSource(store, alias);
}
public String getStore() {
return store;
}
public String getAlias() {
return alias;
}
}
}
| 3,223
| 34.428571
| 135
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/CredentialStoreConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.CredentialStoreConfiguration.CREDENTIAL;
import static org.infinispan.server.configuration.security.CredentialStoreConfiguration.NAME;
import static org.infinispan.server.configuration.security.CredentialStoreConfiguration.PATH;
import static org.infinispan.server.configuration.security.CredentialStoreConfiguration.RELATIVE_TO;
import static org.infinispan.server.configuration.security.CredentialStoreConfiguration.TYPE;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class CredentialStoreConfigurationBuilder implements Builder<CredentialStoreConfiguration> {
private final AttributeSet attributes;
CredentialStoreConfigurationBuilder(String name) {
this.attributes = CredentialStoreConfiguration.attributeDefinitionSet();
attributes.attribute(NAME).set(name);
}
@Override
public AttributeSet attributes() {
return attributes;
}
public CredentialStoreConfigurationBuilder path(String value) {
attributes.attribute(PATH).set(value);
return this;
}
public CredentialStoreConfigurationBuilder relativeTo(String relativeTo) {
attributes.attribute(RELATIVE_TO).set(relativeTo);
return this;
}
public CredentialStoreConfigurationBuilder type(String type) {
attributes.attribute(TYPE).set(type);
return this;
}
public CredentialStoreConfigurationBuilder credential(Supplier<CredentialSource> credential) {
attributes.attribute(CREDENTIAL).set(credential);
return this;
}
@Override
public CredentialStoreConfiguration create() {
return new CredentialStoreConfiguration(attributes.protect());
}
@Override
public Builder<?> read(CredentialStoreConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
}
| 2,238
| 33.984375
| 100
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/OAuth2Configuration.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.CredentialStoresConfiguration.resolvePassword;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.configuration.ServerConfigurationSerializer;
import org.infinispan.server.security.HostnameVerificationPolicy;
import org.wildfly.security.auth.realm.token.TokenValidator;
import org.wildfly.security.auth.realm.token.validator.OAuth2IntrospectValidator;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @since 10.0
*/
public class OAuth2Configuration extends ConfigurationElement<OAuth2Configuration> {
static final AttributeDefinition<String> CLIENT_ID = AttributeDefinition.builder(Attribute.CLIENT_ID, null, String.class).immutable().build();
static final AttributeDefinition<Supplier<CredentialSource>> CLIENT_SECRET = AttributeDefinition.builder(Attribute.CLIENT_SECRET, null, (Class<Supplier<CredentialSource>>) (Class<?>) Supplier.class)
.serializer(ServerConfigurationSerializer.CREDENTIAL).immutable().build();
static final AttributeDefinition<String> CLIENT_SSL_CONTEXT = AttributeDefinition.builder(Attribute.CLIENT_SSL_CONTEXT, null, String.class).immutable().build();
static final AttributeDefinition<String> HOST_VERIFICATION_POLICY = AttributeDefinition.builder(Attribute.HOST_NAME_VERIFICATION_POLICY, null, String.class).immutable().build();
static final AttributeDefinition<String> INTROSPECTION_URL = AttributeDefinition.builder(Attribute.INTROSPECTION_URL, null, String.class).immutable().build();
static final AttributeDefinition<Integer> CONNECTION_TIMEOUT = AttributeDefinition.builder(Attribute.CONNECTION_TIMEOUT, 2000, Integer.class).immutable().build();
static final AttributeDefinition<Integer> READ_TIMEOUT = AttributeDefinition.builder(Attribute.READ_TIMEOUT, 2000, Integer.class).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(OAuth2Configuration.class, CLIENT_ID, CLIENT_SSL_CONTEXT, INTROSPECTION_URL, HOST_VERIFICATION_POLICY, CONNECTION_TIMEOUT, READ_TIMEOUT, CLIENT_SECRET);
}
OAuth2Configuration(AttributeSet attributes) {
super(Element.OAUTH2_INTROSPECTION, attributes);
}
TokenValidator getValidator(SecurityConfiguration security, RealmConfiguration realm) {
OAuth2IntrospectValidator.Builder validatorBuilder = OAuth2IntrospectValidator.builder();
validatorBuilder.clientId(attributes.attribute(CLIENT_ID).get());
validatorBuilder.clientSecret(new String(resolvePassword(attributes.attribute(CLIENT_SECRET))));
final URL url;
try {
url = new URI(attributes.attribute(INTROSPECTION_URL).get()).toURL();
validatorBuilder.tokenIntrospectionUrl(url);
} catch (URISyntaxException | MalformedURLException e) {
throw Server.log.invalidUrl(attributes.attribute(INTROSPECTION_URL).get());
}
if ("https".equalsIgnoreCase(url.getProtocol())) {
RealmConfiguration sslRealm = attributes.attribute(CLIENT_SSL_CONTEXT).isNull() ? realm : security.realms().getRealm(attributes.attribute(CLIENT_SSL_CONTEXT).get());
validatorBuilder.useSslContext(sslRealm.clientSSLContext());
if (!attributes.attribute(HOST_VERIFICATION_POLICY).isNull()) {
validatorBuilder.useSslHostnameVerifier(HostnameVerificationPolicy.valueOf(attributes.attribute(HOST_VERIFICATION_POLICY).get()).getVerifier());
}
}
return validatorBuilder.build();
}
}
| 4,029
| 60.060606
| 201
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LdapRealmConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.DistributedRealmConfiguration.NAME;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.security.PasswordCredentialSource;
import org.wildfly.security.auth.realm.ldap.DirContextFactory;
import org.wildfly.security.auth.server.NameRewriter;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @since 10.0
*/
public class LdapRealmConfigurationBuilder implements RealmProviderBuilder<LdapRealmConfiguration> {
private final AttributeSet attributes;
private final LdapIdentityMappingConfigurationBuilder identityMapping;
LdapRealmConfigurationBuilder() {
this.attributes = LdapRealmConfiguration.attributeDefinitionSet();
identityMapping = new LdapIdentityMappingConfigurationBuilder(this);
}
@Override
public AttributeSet attributes() {
return attributes;
}
public LdapIdentityMappingConfigurationBuilder identityMapping() {
return identityMapping;
}
public LdapRealmConfigurationBuilder name(String name) {
attributes.attribute(LdapRealmConfiguration.NAME).set(name);
return this;
}
@Override
public String name() {
return attributes.attribute(NAME).get();
}
public LdapRealmConfigurationBuilder url(String url) {
attributes.attribute(LdapRealmConfiguration.URL).set(url);
return this;
}
public LdapRealmConfigurationBuilder principal(String principal) {
attributes.attribute(LdapRealmConfiguration.PRINCIPAL).set(principal);
return this;
}
public LdapRealmConfigurationBuilder credential(char[] credential) {
attributes.attribute(LdapRealmConfiguration.CREDENTIAL).set(new PasswordCredentialSource(credential));
return this;
}
public LdapRealmConfigurationBuilder credential(Supplier<CredentialSource> credential) {
attributes.attribute(LdapRealmConfiguration.CREDENTIAL).set(credential);
return this;
}
public LdapRealmConfigurationBuilder directEvidenceVerification(boolean value) {
attributes.attribute(LdapRealmConfiguration.DIRECT_EVIDENCE_VERIFICATION).set(value);
return this;
}
public LdapRealmConfigurationBuilder pageSize(int value) {
attributes.attribute(LdapRealmConfiguration.PAGE_SIZE).set(value);
return this;
}
public LdapRealmConfigurationBuilder nameRewriter(NameRewriter rewriter) {
attributes.attribute(LdapRealmConfiguration.NAME_REWRITER).set(rewriter);
return this;
}
public LdapRealmConfigurationBuilder connectionTimeout(int connectionTimeout) {
attributes.attribute(LdapRealmConfiguration.CONNECTION_TIMEOUT).set(connectionTimeout);
return this;
}
public LdapRealmConfigurationBuilder readTimeout(int readTimeout) {
attributes.attribute(LdapRealmConfiguration.READ_TIMEOUT).set(readTimeout);
return this;
}
public LdapRealmConfigurationBuilder connectionPooling(boolean connectionPooling) {
attributes.attribute(LdapRealmConfiguration.CONNECTION_POOLING).set(connectionPooling);
return this;
}
public LdapRealmConfigurationBuilder referralMode(DirContextFactory.ReferralMode referralMode) {
attributes.attribute(LdapRealmConfiguration.REFERRAL_MODE).set(referralMode);
return this;
}
@Override
public void validate() {
identityMapping.validate();
}
@Override
public LdapRealmConfiguration create() {
return new LdapRealmConfiguration(attributes.protect(), identityMapping.create());
}
@Override
public LdapRealmConfigurationBuilder read(LdapRealmConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
identityMapping.read(template.identityMapping(), combine);
return this;
}
@Override
public int compareTo(RealmProviderBuilder o) {
return 0; // Irrelevant
}
boolean isDirectVerificationEnabled() {
Attribute<Boolean> attribute = attributes.attribute(LdapRealmConfiguration.DIRECT_EVIDENCE_VERIFICATION);
return !attribute.isNull() && attribute.get();
}
}
| 4,350
| 32.728682
| 111
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/UserPropertiesConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.io.File;
import java.util.Properties;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
public class UserPropertiesConfiguration extends ConfigurationElement<UserPropertiesConfiguration> {
static final AttributeDefinition<String> DIGEST_REALM_NAME = AttributeDefinition.builder(Attribute.DIGEST_REALM_NAME, null, String.class).build();
static final AttributeDefinition<String> PATH = AttributeDefinition.builder(Attribute.PATH, null, String.class).build();
static final AttributeDefinition<Boolean> PLAIN_TEXT = AttributeDefinition.builder(Attribute.PLAIN_TEXT, false, Boolean.class).build();
static final AttributeDefinition<String> RELATIVE_TO = AttributeDefinition.builder(Attribute.RELATIVE_TO, Server.INFINISPAN_SERVER_CONFIG_PATH, String.class).autoPersist(false).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(UserPropertiesConfiguration.class, DIGEST_REALM_NAME, PATH, PLAIN_TEXT, RELATIVE_TO);
}
UserPropertiesConfiguration(AttributeSet attributes) {
super(Element.USER_PROPERTIES, attributes);
}
public String path() {
return attributes.attribute(PATH).get();
}
public String relativeTo() {
return attributes.attribute(RELATIVE_TO).get();
}
public boolean plainText() {
return attributes.attribute(PLAIN_TEXT).get();
}
public String digestRealmName() {
return attributes.attribute(DIGEST_REALM_NAME).get();
}
public File getFile(Properties properties) {
String path = attributes.attribute(PATH).get();
String relativeTo = properties.getProperty(attributes.attribute(RELATIVE_TO).get());
return new File(ParseUtils.resolvePath(path, relativeTo));
}
}
| 2,148
| 41.98
| 188
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/PropertiesRealmConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.PropertiesRealmConfiguration.GROUPS_ATTRIBUTE;
import static org.infinispan.server.configuration.security.PropertiesRealmConfiguration.NAME;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class PropertiesRealmConfigurationBuilder implements RealmProviderBuilder<PropertiesRealmConfiguration> {
private final UserPropertiesConfigurationBuilder userProperties = new UserPropertiesConfigurationBuilder();
private final GroupsPropertiesConfigurationBuilder groupProperties = new GroupsPropertiesConfigurationBuilder();
private final AttributeSet attributes;
PropertiesRealmConfigurationBuilder() {
this.attributes = PropertiesRealmConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public PropertiesRealmConfigurationBuilder name(String name) {
attributes.attribute(NAME).set(name);
return this;
}
@Override
public String name() {
return attributes.attribute(DistributedRealmConfiguration.NAME).get();
}
public PropertiesRealmConfigurationBuilder groupAttribute(String groupAttribute) {
attributes.attribute(GROUPS_ATTRIBUTE).set(groupAttribute);
return this;
}
public UserPropertiesConfigurationBuilder userProperties() {
return userProperties;
}
public GroupsPropertiesConfigurationBuilder groupProperties() {
return groupProperties;
}
@Override
public void validate() {
userProperties.validate();
groupProperties.validate();
}
@Override
public PropertiesRealmConfiguration create() {
return new PropertiesRealmConfiguration(attributes.protect(), userProperties.create(), groupProperties.create());
}
@Override
public PropertiesRealmConfigurationBuilder read(PropertiesRealmConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
userProperties.read(template.userProperties(), combine);
groupProperties.read(template.groupProperties(), combine);
return this;
}
@Override
public int compareTo(RealmProviderBuilder o) {
return 0; // Irrelevant
}
}
| 2,342
| 32
| 119
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/TokenRealmConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.TokenRealmConfiguration.AUTH_SERVER_URL;
import static org.infinispan.server.configuration.security.TokenRealmConfiguration.CLIENT_ID;
import static org.infinispan.server.configuration.security.TokenRealmConfiguration.NAME;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class TokenRealmConfigurationBuilder implements RealmProviderBuilder<TokenRealmConfiguration> {
private final AttributeSet attributes;
private final JwtConfigurationBuilder jwtConfiguration;
private final OAuth2ConfigurationBuilder oauth2Configuration;
public TokenRealmConfigurationBuilder() {
this.attributes = TokenRealmConfiguration.attributeDefinitionSet();
this.jwtConfiguration = new JwtConfigurationBuilder();
this.oauth2Configuration = new OAuth2ConfigurationBuilder();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public JwtConfigurationBuilder jwtConfiguration() {
return jwtConfiguration;
}
public OAuth2ConfigurationBuilder oauth2Configuration() {
return oauth2Configuration;
}
public TokenRealmConfigurationBuilder name(String name) {
attributes.attribute(NAME).set(name);
return this;
}
@Override
public String name() {
return attributes.attribute(DistributedRealmConfiguration.NAME).get();
}
public TokenRealmConfigurationBuilder authServerUrl(String authServerUrl) {
attributes.attribute(AUTH_SERVER_URL).set(authServerUrl);
return this;
}
public TokenRealmConfigurationBuilder clientId(String clientId) {
attributes.attribute(CLIENT_ID).set(clientId);
return this;
}
public TokenRealmConfigurationBuilder principalClaim(String principalClaim) {
attributes.attribute(TokenRealmConfiguration.PRINCIPAL_CLAIM).set(principalClaim);
return this;
}
@Override
public void validate() {
jwtConfiguration.validate();
oauth2Configuration.validate();
if (oauth2Configuration.isModified() && jwtConfiguration.isModified()) {
throw new CacheConfigurationException("Cannot have both Oauth2 and JWT as validators");
}
}
@Override
public TokenRealmConfiguration create() {
return new TokenRealmConfiguration(jwtConfiguration.create(), oauth2Configuration.create(),
attributes.protect());
}
@Override
public TokenRealmConfigurationBuilder read(TokenRealmConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
jwtConfiguration.read(template.jwtConfiguration(), combine);
oauth2Configuration.read(template.oauth2Configuration(), combine);
return this;
}
@Override
public int compareTo(RealmProviderBuilder o) {
return 0; // Irrelevant
}
}
| 3,037
| 32.384615
| 102
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/TransportSecurityConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.TransportSecurityConfiguration.SECURITY_REALM;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class TransportSecurityConfigurationBuilder implements Builder<TransportSecurityConfiguration> {
private final AttributeSet attributes;
TransportSecurityConfigurationBuilder() {
this.attributes = TransportSecurityConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Override
public void validate() {
}
@Override
public TransportSecurityConfiguration create() {
return new TransportSecurityConfiguration(attributes.protect());
}
@Override
public Builder<?> read(TransportSecurityConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
public TransportSecurityConfigurationBuilder securityRealm(String securityRealm) {
attributes.attribute(SECURITY_REALM).set(securityRealm);
return this;
}
}
| 1,324
| 28.444444
| 105
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/DistributedRealmConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.DistributedRealmConfiguration.NAME;
import static org.infinispan.server.configuration.security.DistributedRealmConfiguration.REALMS;
import java.util.Arrays;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class DistributedRealmConfigurationBuilder implements RealmProviderBuilder<DistributedRealmConfiguration> {
private final AttributeSet attributes;
public DistributedRealmConfigurationBuilder() {
this.attributes = DistributedRealmConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public DistributedRealmConfigurationBuilder name(String name) {
attributes.attribute(NAME).set(name);
return this;
}
@Override
public String name() {
return attributes.attribute(NAME).get();
}
public DistributedRealmConfigurationBuilder realms(String[] realms) {
attributes.attribute(REALMS).set(Arrays.asList(realms));
return this;
}
@Override
public DistributedRealmConfiguration create() {
return new DistributedRealmConfiguration(attributes.protect());
}
@Override
public Builder<?> read(DistributedRealmConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public int compareTo(RealmProviderBuilder o) {
return 1; // Must be the last
}
}
| 1,723
| 27.733333
| 114
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/TrustStoreRealmConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.DistributedRealmConfiguration.NAME;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class TrustStoreRealmConfigurationBuilder implements RealmProviderBuilder<TrustStoreRealmConfiguration> {
private final AttributeSet attributes;
TrustStoreRealmConfigurationBuilder() {
this.attributes = TrustStoreRealmConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public TrustStoreRealmConfigurationBuilder name(String name) {
attributes.attribute(TrustStoreRealmConfiguration.NAME).set(name);
return this;
}
@Override
public String name() {
return attributes.attribute(NAME).get();
}
@Override
public TrustStoreRealmConfiguration create() {
return new TrustStoreRealmConfiguration(attributes.protect());
}
@Override
public TrustStoreRealmConfigurationBuilder read(TrustStoreRealmConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public int compareTo(RealmProviderBuilder o) {
return -1; // Must be the first
}
}
| 1,367
| 26.918367
| 112
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/TrustStoreConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.KeyStoreConfiguration.TYPE;
import static org.infinispan.server.configuration.security.TrustStoreConfiguration.PASSWORD;
import static org.infinispan.server.configuration.security.TrustStoreConfiguration.PATH;
import static org.infinispan.server.configuration.security.TrustStoreConfiguration.PROVIDER;
import static org.infinispan.server.configuration.security.TrustStoreConfiguration.RELATIVE_TO;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.security.PasswordCredentialSource;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @since 12.1
*/
public class TrustStoreConfigurationBuilder implements Builder<TrustStoreConfiguration> {
private final AttributeSet attributes;
private final RealmConfigurationBuilder realmBuilder;
TrustStoreConfigurationBuilder(RealmConfigurationBuilder realmBuilder) {
this.realmBuilder = realmBuilder;
this.attributes = TrustStoreConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public TrustStoreConfigurationBuilder password(char[] password) {
attributes.attribute(PASSWORD).set(new PasswordCredentialSource(password));
return this;
}
public TrustStoreConfigurationBuilder password(Supplier<CredentialSource> password) {
attributes.attribute(PASSWORD).set(password);
return this;
}
public TrustStoreConfigurationBuilder path(String path) {
attributes.attribute(PATH).set(path);
return this;
}
public TrustStoreConfigurationBuilder provider(String value) {
attributes.attribute(PROVIDER).set(value);
return this;
}
public TrustStoreConfigurationBuilder type(String value) {
attributes.attribute(TYPE).set(value);
return this;
}
public TrustStoreConfigurationBuilder relativeTo(String relativeTo) {
attributes.attribute(RELATIVE_TO).set(relativeTo);
return this;
}
@Override
public TrustStoreConfiguration create() {
return new TrustStoreConfiguration(attributes.protect());
}
@Override
public TrustStoreConfigurationBuilder read(TrustStoreConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 2,566
| 33.226667
| 98
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LocalRealmConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.EnumSet;
import java.util.Properties;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityRealm;
/**
* @since 10.0
*/
public class LocalRealmConfiguration extends ConfigurationElement<LocalRealmConfiguration> implements RealmProvider {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, "local", String.class).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(LocalRealmConfiguration.class, NAME);
}
LocalRealmConfiguration(AttributeSet attributes) {
super(Element.LOCAL_REALM, attributes);
}
@Override
public String name() {
return attributes.attribute(NAME).get();
}
@Override
public SecurityRealm build(SecurityConfiguration securityConfiguration, RealmConfiguration realm, SecurityDomain.Builder domainBuilder, Properties properties) {
return null;
}
@Override
public void applyFeatures(EnumSet<ServerSecurityRealm.Feature> features) {
// Nothing to do
}
}
| 1,524
| 33.659091
| 163
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/OAuth2ConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.security.PasswordCredentialSource;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @since 10.0
*/
public class OAuth2ConfigurationBuilder implements Builder<OAuth2Configuration> {
private final AttributeSet attributes;
OAuth2ConfigurationBuilder() {
this.attributes = OAuth2Configuration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
boolean isModified() {
return this.attributes.isModified();
}
public OAuth2ConfigurationBuilder clientId(String clientId) {
attributes.attribute(OAuth2Configuration.CLIENT_ID).set(clientId);
return this;
}
public OAuth2ConfigurationBuilder clientSecret(char[] clientSecret) {
attributes.attribute(OAuth2Configuration.CLIENT_SECRET).set(new PasswordCredentialSource(clientSecret));
return this;
}
public OAuth2ConfigurationBuilder clientSecret(Supplier<CredentialSource> clientSecret) {
attributes.attribute(OAuth2Configuration.CLIENT_SECRET).set(clientSecret);
return this;
}
public OAuth2ConfigurationBuilder introspectionUrl(String introspectionUrl) {
attributes.attribute(OAuth2Configuration.INTROSPECTION_URL).set(introspectionUrl);
return this;
}
public OAuth2ConfigurationBuilder clientSSLContext(String value) {
attributes.attribute(OAuth2Configuration.CLIENT_SSL_CONTEXT).set(value);
return this;
}
public OAuth2ConfigurationBuilder hostVerificationPolicy(String value) {
attributes.attribute(OAuth2Configuration.HOST_VERIFICATION_POLICY).set(value);
return this;
}
public OAuth2ConfigurationBuilder connectionTimeout(int timeout) {
attributes.attribute(OAuth2Configuration.CONNECTION_TIMEOUT).set(timeout);
return this;
}
public OAuth2ConfigurationBuilder readTimeout(int timeout) {
attributes.attribute(OAuth2Configuration.READ_TIMEOUT).set(timeout);
return this;
}
@Override
public OAuth2Configuration create() {
return new OAuth2Configuration(attributes.protect());
}
@Override
public OAuth2ConfigurationBuilder read(OAuth2Configuration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 2,582
| 30.888889
| 110
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LdapUserPasswordMapperConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.Server;
/**
* @since 10.0
*/
public class LdapUserPasswordMapperConfigurationBuilder implements Builder<LdapUserPasswordMapperConfiguration> {
private final AttributeSet attributes;
private final LdapRealmConfigurationBuilder ldapConfigurationBuilder;
LdapUserPasswordMapperConfigurationBuilder(LdapRealmConfigurationBuilder ldapConfigurationBuilder) {
this.ldapConfigurationBuilder = ldapConfigurationBuilder;
attributes = LdapUserPasswordMapperConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public LdapUserPasswordMapperConfigurationBuilder from(String from) {
attributes.attribute(LdapUserPasswordMapperConfiguration.FROM).set(from);
return this;
}
public LdapUserPasswordMapperConfigurationBuilder verifiable(boolean verifiable) {
attributes.attribute(LdapUserPasswordMapperConfiguration.VERIFIABLE).set(verifiable);
return this;
}
@Override
public LdapUserPasswordMapperConfiguration create() {
return new LdapUserPasswordMapperConfiguration(attributes.protect());
}
@Override
public LdapUserPasswordMapperConfigurationBuilder read(LdapUserPasswordMapperConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public void validate() {
if (ldapConfigurationBuilder.isDirectVerificationEnabled() && attributes.attribute(LdapUserPasswordMapperConfiguration.FROM).isNull()) {
throw Server.log.ldapDirectVerificationWithoutUserMapper();
}
}
}
| 1,875
| 34.396226
| 142
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/PropertiesRealmConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.io.File;
import java.util.EnumSet;
import java.util.Properties;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.ServerSecurityRealm;
import org.infinispan.server.security.realm.PropertiesSecurityRealm;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityRealm;
/**
* @since 10.0
*/
@BuiltBy(PropertiesRealmConfigurationBuilder.class)
public class PropertiesRealmConfiguration extends ConfigurationElement<PropertiesRealmConfiguration> implements RealmProvider {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, "properties", String.class).immutable().build();
static final AttributeDefinition<String> GROUPS_ATTRIBUTE = AttributeDefinition.builder(Attribute.GROUPS_ATTRIBUTE, "groups", String.class).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(PropertiesRealmConfiguration.class, NAME, GROUPS_ATTRIBUTE);
}
private final UserPropertiesConfiguration userPropertiesConfiguration;
private final GroupsPropertiesConfiguration groupsPropertiesConfiguration;
PropertiesRealmConfiguration(AttributeSet attributes, UserPropertiesConfiguration userPropertiesConfiguration,
GroupsPropertiesConfiguration groupsPropertiesConfiguration) {
super(Element.PROPERTIES_REALM, attributes, userPropertiesConfiguration, groupsPropertiesConfiguration);
this.userPropertiesConfiguration = userPropertiesConfiguration;
this.groupsPropertiesConfiguration = groupsPropertiesConfiguration;
}
public UserPropertiesConfiguration userProperties() {
return userPropertiesConfiguration;
}
public GroupsPropertiesConfiguration groupProperties() {
return groupsPropertiesConfiguration;
}
@Override
public SecurityRealm build(SecurityConfiguration securityConfiguration, RealmConfiguration realm, SecurityDomain.Builder domainBuilder, Properties properties) {
File usersFile = userPropertiesConfiguration.getFile(properties);
File groupsFile = groupsPropertiesConfiguration.getFile(properties);
String groupsAttribute = attributes.attribute(GROUPS_ATTRIBUTE).get();
boolean plainText = userPropertiesConfiguration.plainText();
String realmName = userPropertiesConfiguration.digestRealmName();
PropertiesSecurityRealm propertiesSecurityRealm = new PropertiesSecurityRealm(usersFile, groupsFile, plainText, groupsAttribute, realmName);
realm.setHttpChallengeReadiness(() -> !propertiesSecurityRealm.isEmpty());
return propertiesSecurityRealm;
}
@Override
public String name() {
return attributes.attribute(NAME).get();
}
@Override
public void applyFeatures(EnumSet<ServerSecurityRealm.Feature> features) {
features.add(ServerSecurityRealm.Feature.PASSWORD_PLAIN);
features.add(ServerSecurityRealm.Feature.PASSWORD_HASHED);
}
}
| 3,369
| 46.464789
| 163
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/SSLConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.EnumSet;
import java.util.Properties;
import org.infinispan.commons.util.SslContextFactory;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.ssl.SSLContextBuilder;
/**
* @since 10.0
*/
public class SSLConfiguration {
private final KeyStoreConfiguration keyStore;
private final TrustStoreConfiguration trustStore;
private final SSLEngineConfiguration engine;
SSLConfiguration(KeyStoreConfiguration keyStore, TrustStoreConfiguration trustStore, SSLEngineConfiguration engine) {
this.keyStore = keyStore;
this.trustStore = trustStore;
this.engine = engine;
}
public KeyStoreConfiguration keyStore() {
return keyStore;
}
public TrustStoreConfiguration trustStore() {
return trustStore;
}
public SSLEngineConfiguration engine() {
return engine;
}
SSLContextBuilder build(Properties properties, EnumSet<ServerSecurityRealm.Feature> features) {
SSLContextBuilder builder = new SSLContextBuilder().setWrap(false).setProviderName(SslContextFactory.getSslProvider());
keyStore.build(builder, properties, features);
trustStore.build(builder, properties);
engine.build(builder);
return builder;
}
}
| 1,312
| 28.177778
| 125
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/DistributedRealmConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;
import java.util.Properties;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.auth.realm.DistributedSecurityRealm;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityRealm;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class DistributedRealmConfiguration extends ConfigurationElement<DistributedRealmConfiguration> implements RealmProvider {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder("name", "distributed", String.class).build();
static final AttributeDefinition<List<String>> REALMS = AttributeDefinition.builder("realms", null, (Class<List<String>>) (Class<?>) List.class)
.initializer(ArrayList::new).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(DistributedRealmConfiguration.class, NAME, REALMS);
}
DistributedRealmConfiguration(AttributeSet attributes) {
super(Element.DISTRIBUTED_REALM, attributes);
}
@Override
public SecurityRealm build(SecurityConfiguration securityConfiguration, RealmConfiguration realm, SecurityDomain.Builder domainBuilder, Properties properties) {
domainBuilder.setDefaultRealmName(name()); // We make this the default realm
List<String> names = realms();
SecurityRealm[] securityRealms;
if (names.isEmpty()) { // we add all realms
securityRealms = realm.realms().values().toArray(new SecurityRealm[0]);
} else { // only the specified realms
securityRealms = new SecurityRealm[names.size()];
for (int i = 0; i < names.size(); i++) {
SecurityRealm securityRealm = realm.realms().get(names.get(i));
if (securityRealm == null) {
throw Server.log.unknownRealm(names.get(i));
} else {
securityRealms[i] = securityRealm;
}
}
}
return new DistributedSecurityRealm(securityRealms);
}
public String name() {
return attributes.attribute(NAME).get();
}
public List<String> realms() {
return attributes.attribute(REALMS).get();
}
@Override
public void applyFeatures(EnumSet<ServerSecurityRealm.Feature> features) {
// Nothing to do
}
}
| 2,764
| 39.072464
| 163
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/SSLEngineConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class SSLEngineConfigurationBuilder implements Builder<SSLEngineConfiguration> {
private final AttributeSet attributes;
private final RealmConfigurationBuilder realmBuilder;
SSLEngineConfigurationBuilder(RealmConfigurationBuilder realmBuilder) {
this.realmBuilder = realmBuilder;
attributes = SSLEngineConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public SSLEngineConfigurationBuilder enabledProtocols(String[] protocols) {
attributes.attribute(SSLEngineConfiguration.ENABLED_PROTOCOLS).set(protocols);
return this;
}
public SSLEngineConfigurationBuilder enabledCiphersuitesFilter(String cipherSuitesFilter) {
attributes.attribute(SSLEngineConfiguration.ENABLED_CIPHERSUITES).set(cipherSuitesFilter);
return this;
}
public SSLEngineConfigurationBuilder enabledCiphersuitesNames(String cipherSuitesNames) {
attributes.attribute(SSLEngineConfiguration.ENABLED_CIPHERSUITES_13).set(cipherSuitesNames);
return this;
}
@Override
public SSLEngineConfiguration create() {
return new SSLEngineConfiguration(attributes.protect());
}
@Override
public SSLEngineConfigurationBuilder read(SSLEngineConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 1,653
| 32.08
| 98
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LocalRealmConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.DistributedRealmConfiguration.NAME;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class LocalRealmConfigurationBuilder implements RealmProviderBuilder<LocalRealmConfiguration> {
private final AttributeSet attributes;
LocalRealmConfigurationBuilder() {
this.attributes = LocalRealmConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public LocalRealmConfigurationBuilder name(String name) {
attributes.attribute(LocalRealmConfiguration.NAME).set(name);
return this;
}
@Override
public String name() {
return attributes.attribute(NAME).get();
}
@Override
public LocalRealmConfiguration create() {
return new LocalRealmConfiguration(attributes.protect());
}
@Override
public LocalRealmConfigurationBuilder read(LocalRealmConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public int compareTo(RealmProviderBuilder o) {
return 0; // Irrelevant
}
}
| 1,309
| 25.734694
| 102
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/KeyStoreConfiguration.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.CredentialStoresConfiguration.resolvePassword;
import static org.infinispan.server.security.KeyStoreUtils.buildFilelessKeyStore;
import static org.wildfly.security.provider.util.ProviderUtil.findProvider;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.security.Provider;
import java.util.EnumSet;
import java.util.Properties;
import java.util.function.Supplier;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.X509ExtendedKeyManager;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.util.SslContextFactory;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.configuration.ServerConfigurationSerializer;
import org.infinispan.server.security.KeyStoreUtils;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.credential.source.CredentialSource;
import org.wildfly.security.keystore.AliasFilter;
import org.wildfly.security.keystore.FilteringKeyStore;
import org.wildfly.security.keystore.KeyStoreUtil;
import org.wildfly.security.ssl.SSLContextBuilder;
/**
* @since 10.0
*/
public class KeyStoreConfiguration extends ConfigurationElement<KeyStoreConfiguration> {
static final AttributeDefinition<String> ALIAS = AttributeDefinition.builder(Attribute.ALIAS, null, String.class).build();
static final AttributeDefinition<String> GENERATE_SELF_SIGNED_CERTIFICATE_HOST = AttributeDefinition.builder(Attribute.GENERATE_SELF_SIGNED_CERTIFICATE_HOST, null, String.class).build();
@Deprecated
static final AttributeDefinition<Supplier<CredentialSource>> KEY_PASSWORD = AttributeDefinition.builder(Attribute.KEY_PASSWORD, null, (Class<Supplier<CredentialSource>>) (Class<?>) Supplier.class)
.serializer(ServerConfigurationSerializer.CREDENTIAL).build();
static final AttributeDefinition<Supplier<CredentialSource>> KEYSTORE_PASSWORD = AttributeDefinition.builder(Attribute.PASSWORD, null, (Class<Supplier<CredentialSource>>) (Class<?>) Supplier.class)
.serializer(ServerConfigurationSerializer.CREDENTIAL).build();
static final AttributeDefinition<String> PATH = AttributeDefinition.builder(Attribute.PATH, null, String.class).build();
static final AttributeDefinition<String> RELATIVE_TO = AttributeDefinition.builder(Attribute.RELATIVE_TO, Server.INFINISPAN_SERVER_CONFIG_PATH, String.class).autoPersist(false).build();
static final AttributeDefinition<String> PROVIDER = AttributeDefinition.builder(Attribute.PROVIDER, null, String.class).build();
static final AttributeDefinition<String> TYPE = AttributeDefinition.builder(Attribute.TYPE, null, String.class).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(KeyStoreConfiguration.class, ALIAS, GENERATE_SELF_SIGNED_CERTIFICATE_HOST, PATH, RELATIVE_TO, PROVIDER, KEY_PASSWORD, KEYSTORE_PASSWORD, TYPE);
}
KeyStoreConfiguration(AttributeSet attributes) {
super(Element.KEYSTORE, attributes);
}
public void build(SSLContextBuilder builder, Properties properties, EnumSet<ServerSecurityRealm.Feature> features) {
if (attributes.isModified()) {
Provider[] providers = SslContextFactory.discoverSecurityProviders(Thread.currentThread().getContextClassLoader());
try {
final KeyStore keyStore;
String providerName = attributes.attribute(PROVIDER).get();
String type = attributes.attribute(TYPE).get();
if (attributes.attribute(PATH).isNull()) {
keyStore = buildFilelessKeyStore(providers, providerName, type);
} else {
keyStore = buildKeyStore(providers, properties);
}
String algorithm = KeyManagerFactory.getDefaultAlgorithm();
Provider provider = findProvider(providers, providerName, KeyManagerFactory.class, algorithm);
KeyManagerFactory keyManagerFactory = provider != null ? KeyManagerFactory.getInstance(algorithm, provider) : KeyManagerFactory.getInstance(algorithm);
char[] keyStorePassword = resolvePassword(attributes.attribute(KEYSTORE_PASSWORD));
char[] keyPassword = resolvePassword(attributes.attribute(KEY_PASSWORD));
keyManagerFactory.init(keyStore, keyPassword != null ? keyPassword : keyStorePassword);
for (KeyManager keyManager : keyManagerFactory.getKeyManagers()) {
if (keyManager instanceof X509ExtendedKeyManager) {
builder.setKeyManager((X509ExtendedKeyManager) keyManager);
features.add(ServerSecurityRealm.Feature.ENCRYPT);
return;
}
}
throw Server.log.noDefaultKeyManager();
} catch (Exception e) {
throw new CacheConfigurationException(e);
}
}
}
private KeyStore buildKeyStore(Provider[] providers, Properties properties) throws GeneralSecurityException, IOException {
String keyStoreFileName = ParseUtils.resolvePath(attributes.attribute(PATH).get(),
properties.getProperty(attributes.attribute(RELATIVE_TO).get()));
String generateSelfSignedHost = attributes.attribute(GENERATE_SELF_SIGNED_CERTIFICATE_HOST).get();
String provider = attributes.attribute(PROVIDER).get();
char[] keyStorePassword = resolvePassword(attributes.attribute(KEYSTORE_PASSWORD));
char[] keyPassword = resolvePassword(attributes.attribute(KEY_PASSWORD));
String keyAlias = attributes.attribute(ALIAS).get();
if (!new File(keyStoreFileName).exists() && generateSelfSignedHost != null) {
KeyStoreUtils.generateSelfSignedCertificate(keyStoreFileName, provider, keyStorePassword,
keyPassword, keyAlias, generateSelfSignedHost);
}
KeyStore keyStore = KeyStoreUtil.loadKeyStore(() -> providers, provider, new FileInputStream(keyStoreFileName), keyStoreFileName, keyStorePassword);
if (keyAlias != null) {
if (!keyStore.containsAlias(keyAlias)) {
throw Server.log.aliasNotInKeystore(keyAlias, keyStoreFileName);
}
keyStore = FilteringKeyStore.filteringKeyStore(keyStore, AliasFilter.fromString(keyAlias));
}
return keyStore;
}
}
| 6,847
| 57.529915
| 200
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/RealmProviderBuilder.java
|
package org.infinispan.server.configuration.security;
import org.infinispan.commons.configuration.Builder;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public interface RealmProviderBuilder<T extends RealmProvider> extends Builder<T>, Comparable<RealmProviderBuilder> {
String name();
}
| 329
| 26.5
| 117
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/SSLEngineConfiguration.java
|
package org.infinispan.server.configuration.security;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSerializer;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.wildfly.security.ssl.CipherSuiteSelector;
import org.wildfly.security.ssl.ProtocolSelector;
import org.wildfly.security.ssl.SSLContextBuilder;
/**
* @since 10.0
*/
public class SSLEngineConfiguration extends ConfigurationElement<SSLEngineConfiguration> {
static final AttributeDefinition<String[]> ENABLED_PROTOCOLS = AttributeDefinition.builder(Attribute.ENABLED_PROTOCOLS, null, String[].class)
.serializer(AttributeSerializer.STRING_ARRAY).immutable().build();
static final AttributeDefinition<String> ENABLED_CIPHERSUITES = AttributeDefinition.builder(Attribute.ENABLED_CIPHERSUITES, "DEFAULT", String.class)
.immutable().build();
static final AttributeDefinition<String> ENABLED_CIPHERSUITES_13 = AttributeDefinition.builder(Attribute.ENABLED_CIPHERSUITES_TLS13, CipherSuiteSelector.OPENSSL_DEFAULT_CIPHER_SUITE_NAMES, String.class)
.immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(SSLEngineConfiguration.class, ENABLED_PROTOCOLS, ENABLED_CIPHERSUITES, ENABLED_CIPHERSUITES_13);
}
SSLEngineConfiguration(AttributeSet attributes) {
super(Element.ENGINE, attributes);
}
void build(SSLContextBuilder builder) {
attributes.attribute(ENABLED_PROTOCOLS).apply(protocols -> {
ProtocolSelector protocolSelector = ProtocolSelector.empty();
for (String protocol : protocols) {
protocolSelector = protocolSelector.add(protocol);
}
builder.setProtocolSelector(protocolSelector);
});
CipherSuiteSelector cipherSuiteFilter = CipherSuiteSelector.fromString(attributes.attribute(ENABLED_CIPHERSUITES).get());
String cipherSuiteNames = attributes.attribute(ENABLED_CIPHERSUITES_13).get();
builder.setCipherSuiteSelector(CipherSuiteSelector.aggregate(cipherSuiteNames != null ? CipherSuiteSelector.fromNamesString(cipherSuiteNames) : null, cipherSuiteFilter));
}
}
| 2,417
| 51.565217
| 205
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LdapIdentityMappingConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.SEARCH_RECURSIVE;
import static org.infinispan.server.configuration.security.LdapIdentityMappingConfiguration.FILTER_NAME;
import static org.infinispan.server.configuration.security.LdapIdentityMappingConfiguration.RDN_IDENTIFIER;
import static org.infinispan.server.configuration.security.LdapIdentityMappingConfiguration.SEARCH_BASE_DN;
import static org.infinispan.server.configuration.security.LdapIdentityMappingConfiguration.SEARCH_TIME_LIMIT;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class LdapIdentityMappingConfigurationBuilder implements Builder<LdapIdentityMappingConfiguration> {
private final AttributeSet attributes;
private final List<LdapAttributeConfigurationBuilder> attributeMappings = new ArrayList<>();
private final LdapUserPasswordMapperConfigurationBuilder userPasswordMapper;
LdapIdentityMappingConfigurationBuilder(LdapRealmConfigurationBuilder ldapConfigurationBuilder) {
this.userPasswordMapper = new LdapUserPasswordMapperConfigurationBuilder(ldapConfigurationBuilder);
this.attributes = LdapIdentityMappingConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public LdapIdentityMappingConfigurationBuilder rdnIdentifier(String rdnIdentifier) {
attributes.attribute(RDN_IDENTIFIER).set(rdnIdentifier);
return this;
}
public LdapIdentityMappingConfigurationBuilder searchBaseDn(String searchBaseDn) {
attributes.attribute(SEARCH_BASE_DN).set(searchBaseDn);
return this;
}
public LdapIdentityMappingConfigurationBuilder searchRecursive(boolean searchRecursive) {
attributes.attribute(SEARCH_RECURSIVE).set(searchRecursive);
return this;
}
public LdapIdentityMappingConfigurationBuilder searchTimeLimit(int searchTimeLimit) {
attributes.attribute(SEARCH_TIME_LIMIT).set(searchTimeLimit);
return this;
}
public LdapIdentityMappingConfigurationBuilder filterName(String filterName) {
attributes.attribute(FILTER_NAME).set(filterName);
return this;
}
public LdapAttributeConfigurationBuilder addAttributeMapping() {
LdapAttributeConfigurationBuilder builder = new LdapAttributeConfigurationBuilder();
attributeMappings.add(builder);
return builder;
}
public LdapUserPasswordMapperConfigurationBuilder userPasswordMapper() {
return userPasswordMapper;
}
@Override
public void validate() {
attributeMappings.forEach(Builder::validate);
userPasswordMapper.validate();
}
@Override
public LdapIdentityMappingConfiguration create() {
List<LdapAttributeConfiguration> mappingConfigurations = attributeMappings.stream()
.map(LdapAttributeConfigurationBuilder::create).collect(Collectors.toList());
return new LdapIdentityMappingConfiguration(attributes.protect(), mappingConfigurations, userPasswordMapper.create());
}
@Override
public LdapIdentityMappingConfigurationBuilder read(LdapIdentityMappingConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
attributeMappings.clear();
template.attributeMappings().forEach(a -> addAttributeMapping().read(a, combine));
userPasswordMapper.read(template.userPasswordMapper(), combine);
return this;
}
}
| 3,723
| 39.043011
| 124
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/RealmConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.RealmConfiguration.CACHE_LIFESPAN;
import static org.infinispan.server.configuration.security.RealmConfiguration.CACHE_MAX_SIZE;
import static org.infinispan.server.configuration.security.RealmConfiguration.DEFAULT_REALM;
import static org.infinispan.server.configuration.security.RealmConfiguration.EVIDENCE_DECODER;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.util.Util;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Element;
import org.wildfly.security.auth.server.EvidenceDecoder;
/**
* @since 10.0
*/
public class RealmConfigurationBuilder implements Builder<RealmConfiguration> {
private final AttributeSet attributes;
private final ServerIdentitiesConfigurationBuilder serverIdentitiesConfiguration = new ServerIdentitiesConfigurationBuilder(this);
private final List<RealmProviderBuilder<?>> builders = new ArrayList<>();
RealmConfigurationBuilder(String name) {
this.attributes = RealmConfiguration.attributeDefinitionSet();
attributes.attribute(RealmConfiguration.NAME).set(name);
}
@Override
public AttributeSet attributes() {
return attributes;
}
public RealmConfigurationBuilder defaultRealm(String defaultRealm) {
this.attributes.attribute(DEFAULT_REALM).set(defaultRealm);
return this;
}
public RealmConfigurationBuilder cacheMaxSize(int size) {
this.attributes.attribute(CACHE_MAX_SIZE).set(size);
return this;
}
public RealmConfigurationBuilder cacheLifespan(long lifespan) {
this.attributes.attribute(CACHE_LIFESPAN).set(lifespan);
return this;
}
public RealmConfigurationBuilder evidenceDecoder(EvidenceDecoder evidenceDecoder) {
this.attributes.attribute(EVIDENCE_DECODER).set(evidenceDecoder);
return this;
}
public AggregateRealmConfigurationBuilder aggregateConfiguration() {
return addBuilder(Element.AGGREGATE_REALM, new AggregateRealmConfigurationBuilder());
}
public DistributedRealmConfigurationBuilder distributedConfiguration() {
return addBuilder(Element.DISTRIBUTED_REALM, new DistributedRealmConfigurationBuilder());
}
public LdapRealmConfigurationBuilder ldapConfiguration() {
return addBuilder(Element.LDAP_REALM, new LdapRealmConfigurationBuilder());
}
public LocalRealmConfigurationBuilder localConfiguration() {
return addBuilder(Element.LOCAL_REALM, new LocalRealmConfigurationBuilder());
}
public TokenRealmConfigurationBuilder tokenConfiguration() {
return addBuilder(Element.TOKEN_REALM, new TokenRealmConfigurationBuilder());
}
public TrustStoreRealmConfigurationBuilder trustStoreConfiguration() {
return addBuilder(Element.TRUSTSTORE_REALM, new TrustStoreRealmConfigurationBuilder());
}
public PropertiesRealmConfigurationBuilder propertiesConfiguration() {
return addBuilder(Element.PROPERTIES_REALM, new PropertiesRealmConfigurationBuilder());
}
public ServerIdentitiesConfigurationBuilder serverIdentitiesConfiguration() {
return serverIdentitiesConfiguration;
}
private <T extends RealmProviderBuilder> T addBuilder(Enum<?> type, T builder) {
for(RealmProviderBuilder<?> b : builders) {
if (b.getClass().equals(builder.getClass())) {
throw Server.log.duplicateRealmType(type.toString(), attributes.attribute(RealmConfiguration.NAME).get());
}
}
builders.add(builder);
return builder;
}
@Override
public void validate() {
serverIdentitiesConfiguration.validate();
Set<String> names = new HashSet<>();
for(RealmProviderBuilder<?> builder : builders) {
if (names.contains(builder.name())) {
throw Server.log.duplicateRealm(builder.name());
}
builder.validate();
}
}
@Override
public RealmConfiguration create() {
Collections.sort(builders);
return new RealmConfiguration(
attributes.protect(),
serverIdentitiesConfiguration.create(),
builders.stream().map(RealmProviderBuilder::create).collect(Collectors.toList())
);
}
@Override
public RealmConfigurationBuilder read(RealmConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
serverIdentitiesConfiguration.read(template.serverIdentitiesConfiguration(), combine);
this.builders.clear();
for(RealmProvider provider : template.realmProviders()) {
RealmProviderBuilder builder = Util.getInstance(provider.getClass().getAnnotation(BuiltBy.class).value().asSubclass(RealmProviderBuilder.class));
builder.read(provider, combine);
builders.add(builder);
}
return this;
}
}
| 5,232
| 36.647482
| 154
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/RealmProvider.java
|
package org.infinispan.server.configuration.security;
import java.util.EnumSet;
import java.util.Properties;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityRealm;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public interface RealmProvider {
SecurityRealm build(SecurityConfiguration securityConfiguration, RealmConfiguration realm, SecurityDomain.Builder domainBuilder, Properties properties);
String name();
void applyFeatures(EnumSet<ServerSecurityRealm.Feature> features);
}
| 645
| 29.761905
| 155
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LdapAttributeConfiguration.java
|
package org.infinispan.server.configuration.security;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.wildfly.security.auth.realm.ldap.AttributeMapping;
import org.wildfly.security.auth.realm.ldap.LdapSecurityRealmBuilder;
/**
* @since 10.0
*/
public class LdapAttributeConfiguration extends ConfigurationElement<LdapAttributeConfiguration> {
static final AttributeDefinition<String> FILTER = AttributeDefinition.builder(Attribute.FILTER, null, String.class).build();
static final AttributeDefinition<String> FILTER_DN = AttributeDefinition.builder(Attribute.FILTER_DN, null, String.class).build();
static final AttributeDefinition<String> FROM = AttributeDefinition.builder(Attribute.FROM, null, String.class).build();
static final AttributeDefinition<String> TO = AttributeDefinition.builder(Attribute.TO, null, String.class).build();
static final AttributeDefinition<String> REFERENCE = AttributeDefinition.builder(Attribute.REFERENCE, null, String.class).build();
static final AttributeDefinition<Boolean> SEARCH_RECURSIVE = AttributeDefinition.builder(Attribute.SEARCH_RECURSIVE, true, Boolean.class).build();
static final AttributeDefinition<Integer> ROLE_RECURSION = AttributeDefinition.builder(Attribute.ROLE_RECURSION, 0, Integer.class).build();
static final AttributeDefinition<String> ROLE_RECURSION_NAME = AttributeDefinition.builder(Attribute.ROLE_RECURSION_NAME, "cn", String.class).build();
static final AttributeDefinition<String> EXTRACT_RDN = AttributeDefinition.builder(Attribute.EXTRACT_RDN, null, String.class).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(LdapAttributeConfiguration.class, FILTER, FILTER_DN, FROM, TO, REFERENCE, SEARCH_RECURSIVE, ROLE_RECURSION, ROLE_RECURSION_NAME, EXTRACT_RDN);
}
LdapAttributeConfiguration(AttributeSet attributes) {
super(attributes.attribute(REFERENCE).isModified() ? Element.ATTRIBUTE_REFERENCE : Element.ATTRIBUTE, attributes);
}
public void build(LdapSecurityRealmBuilder.IdentityMappingBuilder identity) {
AttributeMapping.Builder builder = attributes.attribute(REFERENCE).isModified() ?
AttributeMapping.fromReference(attributes.attribute(REFERENCE).get()) :
AttributeMapping.fromFilter(attributes.attribute(FILTER).get());
attributes.attribute(FILTER_DN).apply(builder::searchDn);
attributes.attribute(FROM).apply(builder::from);
attributes.attribute(TO).apply(builder::to);
attributes.attribute(SEARCH_RECURSIVE).apply(builder::searchRecursively);
attributes.attribute(ROLE_RECURSION).apply(builder::roleRecursion);
attributes.attribute(ROLE_RECURSION_NAME).apply(builder::roleRecursionName);
attributes.attribute(EXTRACT_RDN).apply(builder::extractRdn);
identity.map(builder.build());
}
}
| 3,126
| 65.531915
| 172
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/KerberosSecurityFactoryConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.DEBUG;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.FAIL_CACHE;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.KEYTAB_PATH;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.MECHANISM_NAMES;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.MECHANISM_OIDS;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.MINIMUM_REMAINING_LIFETIME;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.OBTAIN_KERBEROS_TICKET;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.OPTIONS;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.PRINCIPAL;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.RELATIVE_TO;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.REQUEST_LIFETIME;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.REQUIRED;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.SERVER;
import static org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration.WRAP_GSS_CREDENTIAL;
import java.io.File;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Properties;
import org.ietf.jgss.Oid;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.parsing.ParseUtils;
import org.wildfly.common.Assert;
import org.wildfly.security.SecurityFactory;
import org.wildfly.security.asn1.OidsUtil;
import org.wildfly.security.auth.SupportLevel;
import org.wildfly.security.auth.server._private.ElytronMessages;
import org.wildfly.security.credential.Credential;
import org.wildfly.security.credential.source.CredentialSource;
import org.wildfly.security.mechanism.gssapi.GSSCredentialSecurityFactory;
/**
* KerberosSecurityFactoryConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 10.1
*/
public class KerberosSecurityFactoryConfigurationBuilder implements Builder<KerberosSecurityFactoryConfiguration> {
private final AttributeSet attributes;
private final RealmConfigurationBuilder realmBuilder;
private CredentialSource credentialSource;
KerberosSecurityFactoryConfigurationBuilder(RealmConfigurationBuilder realmBuilder) {
this.realmBuilder = realmBuilder;
this.attributes = KerberosSecurityFactoryConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public KerberosSecurityFactoryConfigurationBuilder principal(String principal) {
attributes.attribute(PRINCIPAL).set(principal);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder keyTabPath(String path) {
attributes.attribute(KEYTAB_PATH).set(path);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder relativeTo(String relativeTo) {
attributes.attribute(RELATIVE_TO).set(relativeTo);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder addOption(String name, String value) {
attributes.attribute(OPTIONS).get().put(name, value);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder failCache(long failCache) {
attributes.attribute(FAIL_CACHE).set(failCache);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder minimumRemainingLifetime(int minimumRemainingLifetime) {
attributes.attribute(MINIMUM_REMAINING_LIFETIME).set(minimumRemainingLifetime);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder requestLifetime(int requestLifetime) {
attributes.attribute(REQUEST_LIFETIME).set(requestLifetime);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder server(boolean server) {
attributes.attribute(SERVER).set(server);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder checkKeyTab(boolean checkKeyTab) {
attributes.attribute(REQUIRED).set(checkKeyTab);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder obtainKerberosTicket(boolean obtainKerberosTicket) {
attributes.attribute(OBTAIN_KERBEROS_TICKET).set(obtainKerberosTicket);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder debug(boolean debug) {
attributes.attribute(DEBUG).set(debug);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder wrapGssCredential(boolean wrapGssCredential) {
attributes.attribute(WRAP_GSS_CREDENTIAL).set(wrapGssCredential);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder addMechanismName(String mechanismName) {
attributes.attribute(MECHANISM_NAMES).get().add(mechanismName);
return this;
}
public KerberosSecurityFactoryConfigurationBuilder addMechanismOid(String mechanismOid) {
attributes.attribute(MECHANISM_OIDS).get().add(mechanismOid);
return this;
}
@Override
public KerberosSecurityFactoryConfiguration create() {
return new KerberosSecurityFactoryConfiguration(attributes.protect(), credentialSource);
}
@Override
public KerberosSecurityFactoryConfigurationBuilder read(KerberosSecurityFactoryConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
public CredentialSource build(Properties properties) {
if (credentialSource == null) {
String path = attributes.attribute(KEYTAB_PATH).get();
String relativeTo = properties.getProperty(attributes.attribute(RELATIVE_TO).get());
File keyTab = new File(ParseUtils.resolvePath(path, relativeTo));
GSSCredentialSecurityFactory.Builder builder = GSSCredentialSecurityFactory.builder();
builder
.setKeyTab(keyTab)
.setPrincipal(attributes.attribute(PRINCIPAL).get())
.setCheckKeyTab(attributes.attribute(REQUIRED).get())
.setDebug(attributes.attribute(DEBUG).get())
.setIsServer(attributes.attribute(SERVER).get())
.setObtainKerberosTicket(attributes.attribute(OBTAIN_KERBEROS_TICKET).get())
.setWrapGssCredential(attributes.attribute(WRAP_GSS_CREDENTIAL).get())
.setOptions(attributes.attribute(OPTIONS).get())
.setFailCache(attributes.attribute(FAIL_CACHE).get())
.setRequestLifetime(attributes.attribute(REQUEST_LIFETIME).get())
.setMinimumRemainingLifetime(attributes.attribute(MINIMUM_REMAINING_LIFETIME).get())
;
try {
for (String name : attributes.attribute(MECHANISM_NAMES).get()) {
String oid = OidsUtil.attributeNameToOid(OidsUtil.Category.GSS, name);
builder.addMechanismOid(new Oid(oid));
}
for (String oid : attributes.attribute(MECHANISM_OIDS).get()) {
builder.addMechanismOid(new Oid(oid));
}
credentialSource = fromSecurityFactory(builder.build());
} catch (Exception e) {
throw new CacheConfigurationException(e);
}
}
return credentialSource;
}
// Copy of Elytron's CredentialSource.fromSecurityFactory() to workaround casting
CredentialSource fromSecurityFactory(SecurityFactory<? extends Credential> credentialFactory) {
Assert.checkNotNullParam("credentialFactory", credentialFactory);
return new CredentialSource() {
public SupportLevel getCredentialAcquireSupport(final Class<? extends Credential> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws IOException {
return SupportLevel.POSSIBLY_SUPPORTED;
}
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws IOException {
final Credential credential;
try {
credential = credentialFactory.create();
} catch (GeneralSecurityException e) {
throw ElytronMessages.log.cannotObtainCredentialFromFactory(e);
}
return credential.matches(credentialType, algorithmName, parameterSpec) ? credentialType.cast(credential) : null;
}
};
}
}
| 9,063
| 44.777778
| 199
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/CredentialStoresConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.io.IOException;
import java.util.Map;
import java.util.Properties;
import java.util.function.Supplier;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.PasswordCredentialSource;
import org.wildfly.security.credential.PasswordCredential;
import org.wildfly.security.credential.source.CredentialSource;
import org.wildfly.security.password.interfaces.ClearPassword;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class CredentialStoresConfiguration extends ConfigurationElement<CredentialStoresConfiguration> {
private final Map<String, CredentialStoreConfiguration> credentialStores;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(CredentialStoresConfiguration.class);
}
CredentialStoresConfiguration(AttributeSet attributes, Map<String, CredentialStoreConfiguration> credentialStores, Properties properties) {
super(Element.CREDENTIAL_STORES, attributes);
attributes.checkProtection();
this.credentialStores = credentialStores;
init(properties);
}
public Map<String, CredentialStoreConfiguration> credentialStores() {
return credentialStores;
}
public CredentialSource getCredentialSource(String store, String alias) {
CredentialStoreConfiguration credentialStoreConfiguration;
if (store == null) {
if (credentialStores.size() == 1) {
credentialStoreConfiguration = credentialStores.values().iterator().next();
} else {
throw Server.log.missingCredentialStoreName();
}
} else {
credentialStoreConfiguration = credentialStores.get(store);
}
if (credentialStoreConfiguration == null) {
throw Server.log.unknownCredentialStore(store);
}
PasswordCredential credential = credentialStoreConfiguration.getCredential(alias, PasswordCredential.class);
if (credential == null) {
throw Server.log.unknownCredential(alias, store);
} else {
return new PasswordCredentialSource(credential);
}
}
private void init(Properties properties) {
for (CredentialStoreConfiguration cs : credentialStores.values()) {
cs.init(properties);
}
}
public static char[] resolvePassword(org.infinispan.commons.configuration.attributes.Attribute<Supplier<CredentialSource>> attribute) {
return attribute.isNull() ? null : resolvePassword(attribute.get());
}
public static char[] resolvePassword(Supplier<CredentialSource> supplier) {
try {
CredentialSource credentialSource = supplier.get();
return credentialSource.getCredential(PasswordCredential.class).getPassword(ClearPassword.class).getPassword();
} catch (IOException e) {
throw new CacheConfigurationException(e);
}
}
}
| 3,169
| 38.135802
| 142
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/ServerIdentitiesConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.List;
import org.infinispan.server.Server;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @since 10.0
*/
public class ServerIdentitiesConfiguration {
private final SSLConfiguration sslConfiguration;
private final List<KerberosSecurityFactoryConfiguration> kerberosConfigurations;
ServerIdentitiesConfiguration(SSLConfiguration sslConfiguration, List<KerberosSecurityFactoryConfiguration> kerberosConfigurations) {
this.sslConfiguration = sslConfiguration;
this.kerberosConfigurations = kerberosConfigurations;
}
public SSLConfiguration sslConfiguration() {
return sslConfiguration;
}
public List<KerberosSecurityFactoryConfiguration> kerberosConfigurations() {
return kerberosConfigurations;
}
public CredentialSource getCredentialSource(String serverPrincipal) {
for (KerberosSecurityFactoryConfiguration configuration : kerberosConfigurations) {
if (configuration.getPrincipal().equals(serverPrincipal)) {
return configuration.getCredentialSource();
}
}
throw Server.log.unknownServerIdentity(serverPrincipal);
}
}
| 1,223
| 31.210526
| 136
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/RealmConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.security.GeneralSecurityException;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.function.Supplier;
import javax.net.ssl.SSLContext;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.ServerSecurityRealm;
import org.infinispan.server.security.realm.CachingModifiableSecurityRealm;
import org.infinispan.server.security.realm.CachingSecurityRealm;
import org.wildfly.security.auth.permission.LoginPermission;
import org.wildfly.security.auth.realm.CacheableSecurityRealm;
import org.wildfly.security.auth.server.EvidenceDecoder;
import org.wildfly.security.auth.server.ModifiableSecurityRealm;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityRealm;
import org.wildfly.security.cache.LRURealmIdentityCache;
import org.wildfly.security.cache.RealmIdentityCache;
import org.wildfly.security.permission.PermissionVerifier;
import org.wildfly.security.ssl.SSLContextBuilder;
/**
* @since 10.0
*/
public class RealmConfiguration extends ConfigurationElement<RealmConfiguration> {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, null, String.class).build();
static final AttributeDefinition<String> DEFAULT_REALM = AttributeDefinition.builder(Attribute.DEFAULT_REALM, null, String.class).immutable().build();
static final AttributeDefinition<Integer> CACHE_MAX_SIZE = AttributeDefinition.builder(Attribute.CACHE_MAX_SIZE, 256).build();
static final AttributeDefinition<Long> CACHE_LIFESPAN = AttributeDefinition.builder(Attribute.CACHE_LIFESPAN, 60_000L).build();
static final AttributeDefinition<EvidenceDecoder> EVIDENCE_DECODER = AttributeDefinition.builder(Attribute.EVIDENCE_DECODER, null, EvidenceDecoder.class).immutable().build();
private final EnumSet<ServerSecurityRealm.Feature> features = EnumSet.noneOf(ServerSecurityRealm.Feature.class);
Map<String, SecurityRealm> realms; // visible to DistributedRealmConfiguration
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(RealmConfiguration.class, NAME, DEFAULT_REALM, CACHE_MAX_SIZE, CACHE_LIFESPAN, EVIDENCE_DECODER);
}
private final ServerIdentitiesConfiguration serverIdentitiesConfiguration;
private final List<RealmProvider> realmProviders;
private Supplier<Boolean> httpChallengeReadiness = () -> true;
private ServerSecurityRealm serverSecurityRealm;
private RealmIdentityCache cache;
private SSLContext serverSslContext = null;
private SSLContext clientSslContext = null;
RealmConfiguration(AttributeSet attributes,
ServerIdentitiesConfiguration serverIdentitiesConfiguration,
List<RealmProvider> realmConfigurations) {
super(Element.SECURITY_REALM, attributes);
this.serverIdentitiesConfiguration = serverIdentitiesConfiguration;
this.realmProviders = realmConfigurations;
}
public ServerIdentitiesConfiguration serverIdentitiesConfiguration() {
return serverIdentitiesConfiguration;
}
public List<RealmProvider> realmProviders() {
return realmProviders;
}
public Map<String, SecurityRealm> realms() {
return realms;
}
public String name() {
return attributes.attribute(NAME).get();
}
@Override
public String toString() {
return "RealmConfiguration{" +
"attributes=" + attributes +
", serverIdentitiesConfiguration=" + serverIdentitiesConfiguration +
", realmsConfiguration=" + realmProviders +
'}';
}
public ServerSecurityRealm serverSecurityRealm() {
if (serverSecurityRealm == null) {
throw new IllegalStateException();
}
return serverSecurityRealm;
}
public SSLContext serverSSLContext() {
if (serverSslContext == null) {
throw Server.log.noSSLContext(name());
} else {
return serverSslContext;
}
}
public SSLContext clientSSLContext() {
if (clientSslContext == null) {
throw Server.log.noSSLContext(name());
} else {
return clientSslContext;
}
}
void init(SecurityConfiguration security, Properties properties) {
SSLConfiguration sslConfiguration = serverIdentitiesConfiguration.sslConfiguration();
SSLContextBuilder sslContextBuilder = sslConfiguration != null ? sslConfiguration.build(properties, features) : null;
SecurityDomain.Builder domainBuilder = SecurityDomain.builder();
attributes.attribute(EVIDENCE_DECODER).apply(domainBuilder::setEvidenceDecoder);
domainBuilder.setPermissionMapper((principal, roles) -> PermissionVerifier.from(new LoginPermission()));
if (realmProviders.isEmpty() || !(realmProviders.get(0) instanceof TrustStoreRealmConfiguration)) {
// Initialize the SSLContexts now, because they may be needed for client connections of the LDAP or Token realms
buildSSLContexts(sslContextBuilder);
}
realms = new HashMap<>(realmProviders.size());
for(RealmProvider provider : realmProviders) {
SecurityRealm realm = provider.build(security, this, domainBuilder, properties);
provider.applyFeatures(features);
realms.put(provider.name(), realm);
if (realm != null) {
domainBuilder.addRealm(provider.name(), cacheable(realm)).build();
if (domainBuilder.getDefaultRealmName() == null) {
domainBuilder.setDefaultRealmName(provider.name());
}
}
}
SecurityDomain securityDomain = domainBuilder.build();
if (features.contains(ServerSecurityRealm.Feature.TRUST)) {
sslContextBuilder.setSecurityDomain(securityDomain);
// Initialize the SSLContexts
buildSSLContexts(sslContextBuilder);
}
String name = attributes.attribute(RealmConfiguration.NAME).get();
serverSecurityRealm = new ServerSecurityRealm(name, securityDomain, httpChallengeReadiness, serverIdentitiesConfiguration, features);
}
private void buildSSLContexts(SSLContextBuilder sslContextBuilder) {
try {
if (sslContextBuilder != null) {
serverSslContext = sslContextBuilder.setClientMode(false).build().create();
clientSslContext = sslContextBuilder.setClientMode(true).build().create();
}
} catch (GeneralSecurityException e) {
throw new CacheConfigurationException(e);
}
}
private SecurityRealm cacheable(SecurityRealm realm) {
int maxEntries = attributes.attribute(CACHE_MAX_SIZE).get();
if (maxEntries > 0 && realm instanceof CacheableSecurityRealm) {
if (cache == null) {
cache = new LRURealmIdentityCache(maxEntries, attributes.attribute(CACHE_LIFESPAN).get());
}
if (realm instanceof ModifiableSecurityRealm) {
return new CachingModifiableSecurityRealm((CacheableSecurityRealm) realm, cache);
} else {
return new CachingSecurityRealm((CacheableSecurityRealm) realm, cache);
}
} else {
return realm;
}
}
public boolean hasFeature(ServerSecurityRealm.Feature feature) {
return features.contains(feature);
}
void setHttpChallengeReadiness(Supplier<Boolean> httpChallengeReadiness) {
this.httpChallengeReadiness = httpChallengeReadiness;
}
public void flushCache() {
if (cache != null) {
cache.clear();
}
}
}
| 8,006
| 40.921466
| 177
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/RealmsConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.Map;
import java.util.Properties;
import org.infinispan.server.Server;
import org.infinispan.server.core.logging.Log;
/**
* @since 10.0
*/
public class RealmsConfiguration {
private final Map<String, RealmConfiguration> realms;
RealmsConfiguration(Map<String, RealmConfiguration> realms) {
this.realms = realms;
}
public Map<String, RealmConfiguration> realms() {
return realms;
}
public RealmConfiguration getRealm(String name) {
RealmConfiguration realm = realms.get(name);
if (realm == null) {
throw Server.log.unknownSecurityDomain(name);
} else {
return realm;
}
}
void init(SecurityConfiguration security, Properties properties) {
for(RealmConfiguration realm : realms.values()) {
realm.init(security, properties);
}
}
public void flushRealmCaches() {
for(RealmConfiguration realm : realms.values()) {
realm.flushCache();
Log.SERVER.flushRealmCache(realm.name());
}
}
}
| 1,095
| 23.355556
| 69
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/TransportSecurityConfiguration.java
|
package org.infinispan.server.configuration.security;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.Element;
import org.infinispan.server.configuration.Attribute;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class TransportSecurityConfiguration extends ConfigurationElement<TransportSecurityConfiguration> {
static final AttributeDefinition<String> SECURITY_REALM = AttributeDefinition.builder(Attribute.SECURITY_REALM, null, String.class).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(TrustStoreConfiguration.class, SECURITY_REALM);
}
TransportSecurityConfiguration(AttributeSet attributes) {
super(Element.TRANSPORT, attributes);
}
public String securityRealm() {
return attributes.attribute(SECURITY_REALM).get();
}
}
| 1,075
| 37.428571
| 155
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/rest/Element.java
|
package org.infinispan.server.configuration.rest;
import java.util.HashMap;
import java.util.Map;
/**
* @author Tristan Tarrant
* @since 10.0
*/
public enum Element {
//must be first
UNKNOWN(null),
AUTHENTICATION,
ALLOWED_HEADERS,
ALLOWED_METHODS,
ALLOWED_ORIGINS,
CORS_RULE,
CORS_RULES,
ENCRYPTION,
EXPOSE_HEADERS,
REST_CONNECTOR,
SNI,
;
private static final Map<String, Element> ELEMENTS;
static {
final Map<String, Element> map = new HashMap<>(8);
for (Element element : values()) {
final String name = element.name;
if (name != null) {
map.put(name, element);
}
}
ELEMENTS = map;
}
private final String name;
Element(final String name) {
this.name = name;
}
Element() {
this.name = name().toLowerCase().replace('_', '-');
}
public static Element forName(final String localName) {
final Element element = ELEMENTS.get(localName);
return element == null ? UNKNOWN : element;
}
@Override
public String toString() {
return name;
}
}
| 1,117
| 17.949153
| 58
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/rest/RestServerConfigurationParser.java
|
package org.infinispan.server.configuration.rest;
import static org.infinispan.commons.util.StringPropertyReplacer.replaceProperties;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ConfigurationParser;
import org.infinispan.configuration.parsing.Namespace;
import org.infinispan.configuration.parsing.Namespaces;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.rest.configuration.CorsConfigurationBuilder;
import org.infinispan.rest.configuration.CorsRuleConfigurationBuilder;
import org.infinispan.rest.configuration.ExtendedHeaders;
import org.infinispan.rest.configuration.RestAuthenticationConfigurationBuilder;
import org.infinispan.rest.configuration.RestServerConfigurationBuilder;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.ServerConfigurationBuilder;
import org.infinispan.server.configuration.ServerConfigurationParser;
import org.infinispan.server.configuration.endpoint.EndpointConfigurationBuilder;
import org.infinispan.server.core.configuration.EncryptionConfigurationBuilder;
import org.infinispan.server.core.configuration.SniConfigurationBuilder;
import org.infinispan.server.security.ElytronHTTPAuthenticator;
import org.infinispan.util.logging.LogFactory;
import org.kohsuke.MetaInfServices;
/**
* Server endpoint configuration parser
*
* @author Tristan Tarrant
* @since 10.0
*/
@MetaInfServices
@Namespaces({
@Namespace(root = "rest-connector"),
@Namespace(uri = "urn:infinispan:server:*", root = "rest-connector"),
})
public class RestServerConfigurationParser implements ConfigurationParser {
private static org.infinispan.util.logging.Log coreLog = LogFactory.getLog(ServerConfigurationParser.class);
@Override
public void readElement(ConfigurationReader reader, ConfigurationBuilderHolder holder) {
if (!holder.inScope(ServerConfigurationParser.ENDPOINTS_SCOPE)) {
throw coreLog.invalidScope(ServerConfigurationParser.ENDPOINTS_SCOPE, holder.getScope());
}
GlobalConfigurationBuilder builder = holder.getGlobalConfigurationBuilder();
Element element = Element.forName(reader.getLocalName());
switch (element) {
case REST_CONNECTOR: {
ServerConfigurationBuilder serverBuilder = builder.module(ServerConfigurationBuilder.class);
if (serverBuilder != null) {
parseRest(reader, serverBuilder);
} else {
throw ParseUtils.unexpectedElement(reader);
}
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
@Override
public Namespace[] getNamespaces() {
return ParseUtils.getNamespaceAnnotations(getClass());
}
private void parseRest(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder) {
boolean dedicatedSocketBinding = false;
String securityRealm = null;
EndpointConfigurationBuilder endpoint = serverBuilder.endpoints().current();
RestServerConfigurationBuilder builder = endpoint.addConnector(RestServerConfigurationBuilder.class);
ServerConfigurationParser.configureEndpoint(reader.getProperties(), endpoint, builder);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = replaceProperties(reader.getAttributeValue(i));
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case CONTEXT_PATH: {
builder.contextPath(value);
break;
}
case EXTENDED_HEADERS: {
builder.extendedHeaders(ParseUtils.parseEnum(reader, i, ExtendedHeaders.class, value));
break;
}
case NAME: {
builder.name(value);
break;
}
case MAX_CONTENT_LENGTH: {
builder.maxContentLength(ParseUtils.parseInt(reader, i, value));
break;
}
case COMPRESSION_LEVEL: {
builder.compressionLevel(ParseUtils.parseInt(reader, i, value));
break;
}
case SOCKET_BINDING: {
builder.socketBinding(value);
builder.startTransport(true);
dedicatedSocketBinding = true;
break;
}
case SECURITY_REALM: {
securityRealm = value;
}
default: {
ServerConfigurationParser.parseCommonConnectorAttributes(reader, i, serverBuilder, builder);
}
}
}
if (!dedicatedSocketBinding) {
builder.socketBinding(endpoint.singlePort().socketBinding()).startTransport(false);
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case AUTHENTICATION: {
parseAuthentication(reader, serverBuilder, builder.authentication().enable(), securityRealm);
break;
}
case ENCRYPTION: {
if (!dedicatedSocketBinding) {
throw Server.log.cannotConfigureProtocolEncryptionUnderSinglePort();
}
parseEncryption(reader, serverBuilder, builder.encryption(), securityRealm);
break;
}
case CORS_RULES: {
parseCorsRules(reader, builder);
break;
}
default: {
ServerConfigurationParser.parseCommonConnectorElements(reader, builder);
}
}
}
}
private void parseCorsRules(ConfigurationReader reader, RestServerConfigurationBuilder builder) {
ParseUtils.requireNoAttributes(reader);
CorsConfigurationBuilder cors = builder.cors();
while (reader.inTag()) {
final Element element = Element.forName(reader.getLocalName());
switch (element) {
case CORS_RULES:
case CORS_RULE: {
parseCorsRule(reader, cors.addNewRule());
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private void parseCorsRule(ConfigurationReader reader, CorsRuleConfigurationBuilder corsRule) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME: {
corsRule.name(value);
break;
}
case ALLOW_CREDENTIALS: {
corsRule.allowCredentials(Boolean.parseBoolean(value));
break;
}
case MAX_AGE_SECONDS: {
corsRule.maxAge(Long.parseLong(value));
break;
}
case ALLOWED_HEADERS: {
corsRule.allowHeaders(reader.getListAttributeValue(i));
break;
}
case ALLOWED_ORIGINS: {
corsRule.allowOrigins(reader.getListAttributeValue(i));
break;
}
case ALLOWED_METHODS: {
corsRule.allowMethods(reader.getListAttributeValue(i));
break;
}
case EXPOSE_HEADERS: {
corsRule.exposeHeaders(reader.getListAttributeValue(i));
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (reader.getSchema().since(13,0)) {
ParseUtils.requireNoContent(reader);
} else {
while (reader.inTag()) {
final Element element = Element.forName(reader.getLocalName());
String[] values = reader.getElementText().split(",");
switch (element) {
case ALLOWED_HEADERS: {
corsRule.allowHeaders(values);
break;
}
case ALLOWED_ORIGINS: {
corsRule.allowOrigins(values);
break;
}
case ALLOWED_METHODS: {
corsRule.allowMethods(values);
break;
}
case EXPOSE_HEADERS: {
corsRule.exposeHeaders(values);
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
}
private void parseAuthentication(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, RestAuthenticationConfigurationBuilder builder, String securityRealmName) {
if (securityRealmName == null) {
securityRealmName = serverBuilder.endpoints().current().securityRealm();
}
String serverPrincipal = null;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case SECURITY_REALM: {
builder.securityRealm(value);
securityRealmName = value;
break;
}
case MECHANISMS: {
builder.addMechanisms(reader.getListAttributeValue(i));
break;
}
case SERVER_PRINCIPAL: {
serverPrincipal = value;
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
if (securityRealmName == null) {
throw Server.log.authenticationWithoutSecurityRealm();
}
builder.authenticator(new ElytronHTTPAuthenticator(securityRealmName, serverPrincipal, builder.mechanisms()));
}
private void parseEncryption(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, EncryptionConfigurationBuilder encryption, String securityRealmName) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
String value = reader.getAttributeValue(i);
switch (attribute) {
case REQUIRE_SSL_CLIENT_AUTH: {
encryption.requireClientAuth(Boolean.parseBoolean(value));
break;
}
case SECURITY_REALM: {
securityRealmName = value;
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (securityRealmName == null) {
throw Server.log.encryptionWithoutSecurityRealm();
} else {
encryption.realm(securityRealmName).sslContext(serverBuilder.serverSSLContextSupplier(securityRealmName));
}
while (reader.inTag(Element.ENCRYPTION)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case SNI: {
if (reader.getAttributeCount() > 0) {
parseSni(reader, serverBuilder, encryption.addSni());
}
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private void parseSni(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, SniConfigurationBuilder sni) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case HOST_NAME: {
sni.host(value);
break;
}
case SECURITY_REALM: {
sni.realm(value);
sni.sslContext(serverBuilder.serverSSLContextSupplier(value));
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
}
| 12,759
| 37.318318
| 181
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/rest/Attribute.java
|
package org.infinispan.server.configuration.rest;
import java.util.HashMap;
import java.util.Map;
/**
* @author Tristan Tarrant
* @since 10.0
*/
public enum Attribute {
// must be first
UNKNOWN(null),
ALLOW_CREDENTIALS,
COMPRESSION_LEVEL,
CONTEXT_PATH,
EXTENDED_HEADERS,
HOST_NAME,
MAX_AGE_SECONDS,
MAX_CONTENT_LENGTH,
MECHANISMS,
NAME,
REQUIRE_SSL_CLIENT_AUTH,
SECURITY_REALM,
SERVER_PRINCIPAL,
SOCKET_BINDING,
ALLOWED_HEADERS,
ALLOWED_ORIGINS,
ALLOWED_METHODS,
EXPOSE_HEADERS;
private static final Map<String, Attribute> ATTRIBUTES;
static {
final Map<String, Attribute> map = new HashMap<>(64);
for (Attribute attribute : values()) {
final String name = attribute.name;
if (name != null) {
map.put(name, attribute);
}
}
ATTRIBUTES = map;
}
private final String name;
Attribute(final String name) {
this.name = name;
}
Attribute() {
this.name = name().toLowerCase().replace('_', '-');
}
public static Attribute forName(String localName) {
final Attribute attribute = ATTRIBUTES.get(localName);
return attribute == null ? UNKNOWN : attribute;
}
@Override
public String toString() {
return name;
}
}
| 1,302
| 19.046154
| 60
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/hotrod/HotRodServerConfigurationParser.java
|
package org.infinispan.server.configuration.hotrod;
import static org.infinispan.server.configuration.ServerConfigurationParser.parseSasl;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ConfigurationParser;
import org.infinispan.configuration.parsing.Namespace;
import org.infinispan.configuration.parsing.Namespaces;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.ServerConfigurationBuilder;
import org.infinispan.server.configuration.ServerConfigurationParser;
import org.infinispan.server.core.configuration.EncryptionConfigurationBuilder;
import org.infinispan.server.core.configuration.SaslAuthenticationConfigurationBuilder;
import org.infinispan.server.core.configuration.SniConfigurationBuilder;
import org.infinispan.server.hotrod.configuration.Attribute;
import org.infinispan.server.hotrod.configuration.Element;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.server.security.ElytronSASLAuthenticator;
import org.kohsuke.MetaInfServices;
import org.wildfly.security.sasl.WildFlySasl;
/**
* Server endpoint configuration parser
*
* @author Tristan Tarrant
* @since 10.0
*/
@MetaInfServices
@Namespaces({
@Namespace(root = "hotrod-connector"),
@Namespace(uri = "urn:infinispan:server:*", root = "hotrod-connector"),
})
public class HotRodServerConfigurationParser implements ConfigurationParser {
private static org.infinispan.util.logging.Log coreLog = org.infinispan.util.logging.LogFactory.getLog(ServerConfigurationParser.class);
@Override
public void readElement(ConfigurationReader reader, ConfigurationBuilderHolder holder) {
if (!holder.inScope(ServerConfigurationParser.ENDPOINTS_SCOPE)) {
throw coreLog.invalidScope(ServerConfigurationParser.ENDPOINTS_SCOPE, holder.getScope());
}
GlobalConfigurationBuilder builder = holder.getGlobalConfigurationBuilder();
Element element = Element.forName(reader.getLocalName());
switch (element) {
case HOTROD_CONNECTOR: {
ServerConfigurationBuilder serverBuilder = builder.module(ServerConfigurationBuilder.class);
if (serverBuilder != null) {
parseHotRodConnector(reader, serverBuilder, serverBuilder.endpoints().current().addConnector(HotRodServerConfigurationBuilder.class));
}
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
@Override
public Namespace[] getNamespaces() {
return ParseUtils.getNamespaceAnnotations(getClass());
}
private void parseHotRodConnector(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, HotRodServerConfigurationBuilder builder) {
boolean dedicatedSocketBinding = false;
String securityRealm = null;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case EXTERNAL_HOST: {
builder.proxyHost(value);
break;
}
case EXTERNAL_PORT: {
builder.proxyPort(Integer.parseInt(value));
break;
}
case NAME: {
builder.name(value);
break;
}
case SOCKET_BINDING: {
builder.socketBinding(value);
builder.startTransport(true);
dedicatedSocketBinding = true;
break;
}
case SECURITY_REALM: {
builder.authentication().securityRealm(value);
break;
}
case NETWORK_PREFIX_OVERRIDE: {
builder.topologyNetworkPrefixOverride(Boolean.parseBoolean(value));
break;
}
default: {
ServerConfigurationParser.parseCommonConnectorAttributes(reader, i, serverBuilder, builder);
}
}
}
if (!dedicatedSocketBinding) {
builder.socketBinding(serverBuilder.endpoints().current().singlePort().socketBinding()).startTransport(false);
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case TOPOLOGY_STATE_TRANSFER: {
parseTopologyStateTransfer(reader, builder);
break;
}
case AUTHENTICATION: {
parseAuthentication(reader, serverBuilder, builder.authentication().enable(), securityRealm);
break;
}
case ENCRYPTION: {
if (!dedicatedSocketBinding) {
throw Server.log.cannotConfigureProtocolEncryptionUnderSinglePort();
}
parseEncryption(reader, serverBuilder, builder.encryption(), securityRealm);
break;
}
default: {
ServerConfigurationParser.parseCommonConnectorElements(reader, builder);
}
}
}
}
private void parseEncryption(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, EncryptionConfigurationBuilder encryption, String securityRealm) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case REQUIRE_SSL_CLIENT_AUTH: {
encryption.requireClientAuth(Boolean.parseBoolean(value));
break;
}
case SECURITY_REALM: {
securityRealm = value;
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (securityRealm == null) {
throw Server.log.encryptionWithoutSecurityRealm();
} else {
encryption.realm(securityRealm).sslContext(serverBuilder.serverSSLContextSupplier(securityRealm));
}
while (reader.inTag(Element.ENCRYPTION)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case SNI: {
if (reader.getAttributeCount() > 0) {
parseSni(reader, serverBuilder, encryption.addSni());
}
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private void parseSni(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, SniConfigurationBuilder sni) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case HOST_NAME: {
sni.host(value);
break;
}
case SECURITY_REALM: {
sni.realm(value);
sni.sslContext(serverBuilder.serverSSLContextSupplier(value));
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
private void parseAuthentication(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, SaslAuthenticationConfigurationBuilder builder, String securityRealm) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case SECURITY_REALM: {
securityRealm = value;
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (securityRealm == null) {
securityRealm = serverBuilder.endpoints().current().securityRealm();
}
if (securityRealm == null) {
throw Server.log.authenticationWithoutSecurityRealm();
}
// Automatically set the digest realm name. It can be overridden by the user
builder.sasl().addMechProperty(WildFlySasl.REALM_LIST, securityRealm);
String serverPrincipal = null;
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case SASL: {
serverPrincipal = parseSasl(reader, builder.sasl());
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
builder.securityRealm(securityRealm);
builder.sasl().authenticator(new ElytronSASLAuthenticator(securityRealm, serverPrincipal, builder.sasl().mechanisms()));
}
private void parseTopologyStateTransfer(ConfigurationReader reader, HotRodServerConfigurationBuilder builder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case LOCK_TIMEOUT: {
builder.topologyLockTimeout(Long.parseLong(value));
break;
}
case AWAIT_INITIAL_RETRIEVAL: {
builder.topologyAwaitInitialTransfer(Boolean.parseBoolean(value));
break;
}
case REPLICATION_TIMEOUT: {
builder.topologyReplTimeout(Long.parseLong(value));
break;
}
case LAZY_RETRIEVAL: {
if (reader.getSchema().since(11, 0))
Server.log.warnHotRodLazyRetrievalDeprecated();
builder.topologyStateTransfer(!Boolean.parseBoolean(value));
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
}
| 10,782
| 39.085502
| 177
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/endpoint/EndpointConfigurationBuilder.java
|
package org.infinispan.server.configuration.endpoint;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.rest.configuration.RestAuthenticationConfigurationBuilder;
import org.infinispan.rest.configuration.RestServerConfigurationBuilder;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.ServerConfigurationBuilder;
import org.infinispan.server.configuration.SocketBindingsConfiguration;
import org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration;
import org.infinispan.server.configuration.security.RealmConfiguration;
import org.infinispan.server.configuration.security.SecurityConfiguration;
import org.infinispan.server.core.configuration.AuthenticationConfigurationBuilder;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationBuilder;
import org.infinispan.server.core.configuration.SaslAuthenticationConfigurationBuilder;
import org.infinispan.server.core.configuration.SaslConfigurationBuilder;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.server.memcached.configuration.MemcachedAuthenticationConfigurationBuilder;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder;
import org.infinispan.server.resp.configuration.RespAuthenticationConfigurationBuilder;
import org.infinispan.server.resp.configuration.RespServerConfigurationBuilder;
import org.infinispan.server.security.ElytronHTTPAuthenticator;
import org.infinispan.server.security.ElytronSASLAuthenticator;
import org.infinispan.server.security.ElytronUsernamePasswordAuthenticator;
import org.infinispan.server.security.ElytronRESPAuthenticator;
import org.infinispan.server.security.RespClientCertAuthenticator;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.sasl.util.SaslMechanismInformation;
/**
* @since 12.0
*/
public class EndpointConfigurationBuilder implements Builder<EndpointConfiguration> {
private final AttributeSet attributes;
private final List<ProtocolServerConfigurationBuilder<?, ?, ?>> connectorBuilders = new ArrayList<>(2);
private final SinglePortServerConfigurationBuilder singlePortBuilder = new SinglePortServerConfigurationBuilder();
private boolean implicitConnectorSecurity;
public EndpointConfigurationBuilder(ServerConfigurationBuilder serverConfigurationBuilder, String socketBindingName) {
this.attributes = EndpointConfiguration.attributeDefinitionSet();
attributes.attribute(EndpointConfiguration.SOCKET_BINDING).set(socketBindingName);
singlePortBuilder.socketBinding(socketBindingName);
}
@Override
public AttributeSet attributes() {
return attributes;
}
public EndpointConfigurationBuilder securityRealm(String name) {
attributes.attribute(EndpointConfiguration.SECURITY_REALM).set(name);
return this;
}
public String securityRealm() {
return attributes.attribute(EndpointConfiguration.SECURITY_REALM).get();
}
public EndpointConfigurationBuilder implicitConnectorSecurity(boolean implicitConnectorSecurity) {
this.implicitConnectorSecurity = implicitConnectorSecurity;
return this;
}
public EndpointConfigurationBuilder admin(boolean admin) {
attributes.attribute(EndpointConfiguration.ADMIN).set(admin);
return this;
}
public boolean admin() {
return attributes.attribute(EndpointConfiguration.ADMIN).get();
}
public EndpointConfigurationBuilder metricsAuth(boolean auth) {
attributes.attribute(EndpointConfiguration.METRICS_AUTH).set(auth);
return this;
}
public boolean metricsAuth() {
return attributes.attribute(EndpointConfiguration.METRICS_AUTH).get();
}
public List<ProtocolServerConfigurationBuilder<?, ?, ?>> connectors() {
return connectorBuilders;
}
public SinglePortServerConfigurationBuilder singlePort() {
return singlePortBuilder;
}
public <T extends ProtocolServerConfigurationBuilder<?, ?, ?>> T addConnector(Class<T> klass) {
try {
T builder = klass.getConstructor().newInstance();
connectorBuilders.add(builder);
singlePortBuilder.applyConfigurationToProtocol(builder);
return builder;
} catch (Exception e) {
throw Server.log.cannotInstantiateProtocolServerConfigurationBuilder(klass, e);
}
}
@Override
public void validate() {
Map<String, List<ProtocolServerConfigurationBuilder<?, ?, ?>>> buildersPerClass = connectorBuilders.stream()
.collect(Collectors.groupingBy(s -> s.getClass().getSimpleName() + "/" + s.socketBinding()));
buildersPerClass.values().stream().filter(c -> c.size() > 1).findFirst().ifPresent(c -> {
String names = c.stream().map(ProtocolServerConfigurationBuilder::name).collect(Collectors.joining(","));
throw Server.log.multipleEndpointsSameTypeFound(names);
});
}
@Override
public EndpointConfiguration create() {
throw new UnsupportedOperationException();
}
public EndpointConfiguration create(SocketBindingsConfiguration bindingsConfiguration, SecurityConfiguration securityConfiguration) {
boolean implicitSecurity = implicitConnectorSecurity && securityRealm() != null;
bindingsConfiguration.applySocketBinding(attributes.attribute(EndpointConfiguration.SOCKET_BINDING).get(), singlePortBuilder, singlePortBuilder);
List<ProtocolServerConfiguration<?, ?>> connectors = new ArrayList<>(connectorBuilders.size());
for (ProtocolServerConfigurationBuilder<?, ?, ?> builder : connectorBuilders) {
bindingsConfiguration.applySocketBinding(builder.socketBinding(), builder, singlePortBuilder);
if (implicitSecurity) {
if (builder instanceof HotRodServerConfigurationBuilder) {
enableImplicitAuthentication(securityConfiguration, securityRealm(), (HotRodServerConfigurationBuilder) builder);
} else if (builder instanceof RestServerConfigurationBuilder) {
enableImplicitAuthentication(securityConfiguration, securityRealm(), (RestServerConfigurationBuilder) builder);
} else if (builder instanceof RespServerConfigurationBuilder) {
builder = enableImplicitAuthentication(securityConfiguration, securityRealm(), (RespServerConfigurationBuilder) builder);
} else if (builder instanceof MemcachedServerConfigurationBuilder) {
builder = enableImplicitAuthentication(securityConfiguration, securityRealm(), (MemcachedServerConfigurationBuilder) builder);
}
}
if (builder != null) {
connectors.add(builder.create());
}
}
if (implicitSecurity) {
RealmConfiguration realm = securityConfiguration.realms().getRealm(securityRealm());
if (realm.hasFeature(ServerSecurityRealm.Feature.ENCRYPT)) {
singlePortBuilder.ssl().enable().sslContext(realm.serverSSLContext());
}
}
return new EndpointConfiguration(attributes.protect(), connectors, singlePortBuilder.create());
}
@Override
public EndpointConfigurationBuilder read(EndpointConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
public static void enableImplicitAuthentication(SecurityConfiguration security, String securityRealmName, HotRodServerConfigurationBuilder builder) {
// Set the security realm only if it has not been set already
SaslAuthenticationConfigurationBuilder authentication = builder.authentication();
if (!authentication.hasSecurityRealm()) {
authentication.securityRealm(securityRealmName);
Server.log.debugf("Using endpoint realm \"%s\" for Hot Rod", securityRealmName);
}
ServerSecurityRealm securityRealm = security.realms().getRealm(authentication.securityRealm()).serverSecurityRealm();
// Only add implicit mechanisms if the user has not set any explicitly
enableSaslAuthentication(authentication, authentication.sasl(), securityRealm, "hotrod/", "Hot Rod");
}
private static void enableSaslAuthentication(AuthenticationConfigurationBuilder<?> authentication, SaslConfigurationBuilder sasl, ServerSecurityRealm securityRealm, String identityPrefix, String name) {
if (!sasl.hasMechanisms()) {
String serverPrincipal = null;
for (KerberosSecurityFactoryConfiguration identity : securityRealm.getServerIdentities().kerberosConfigurations()) {
if (identity.getPrincipal().startsWith(identityPrefix)) {
authentication.enable();
sasl.addMechanisms(SaslMechanismInformation.Names.GS2_KRB5, SaslMechanismInformation.Names.GSSAPI);
serverPrincipal = identity.getPrincipal();
break;
}
Server.log.debugf("Enabled Kerberos mechanisms for %s using principal '%s'", name, identity.getPrincipal());
}
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.TOKEN)) {
authentication.enable();
sasl.addMechanisms(SaslMechanismInformation.Names.OAUTHBEARER);
Server.log.debugf("Enabled OAUTHBEARER mechanism for %s", name);
}
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.TRUST)) {
authentication.enable();
sasl.addMechanisms(SaslMechanismInformation.Names.EXTERNAL);
Server.log.debugf("Enabled EXTERNAL mechanism for %s", name);
}
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.PASSWORD_HASHED)) {
authentication.enable();
sasl.addMechanisms(
SaslMechanismInformation.Names.SCRAM_SHA_512,
SaslMechanismInformation.Names.SCRAM_SHA_384,
SaslMechanismInformation.Names.SCRAM_SHA_256,
SaslMechanismInformation.Names.SCRAM_SHA_1,
SaslMechanismInformation.Names.DIGEST_SHA_512,
SaslMechanismInformation.Names.DIGEST_SHA_384,
SaslMechanismInformation.Names.DIGEST_SHA_256,
SaslMechanismInformation.Names.DIGEST_SHA,
SaslMechanismInformation.Names.CRAM_MD5,
SaslMechanismInformation.Names.DIGEST_MD5
);
Server.log.debugf("Enabled SCRAM, DIGEST and CRAM mechanisms for %s", name);
// Only enable PLAIN if encryption is on
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.ENCRYPT)) {
authentication.enable();
sasl.addMechanisms(SaslMechanismInformation.Names.PLAIN);
Server.log.debugf("Enabled PLAIN mechanism for %s", name);
}
}
sasl.authenticator(new ElytronSASLAuthenticator(authentication.securityRealm(), serverPrincipal, sasl.mechanisms()));
}
}
public static void enableImplicitAuthentication(SecurityConfiguration security, String securityRealmName, RestServerConfigurationBuilder builder) {
// Set the security realm only if it has not been set already
RestAuthenticationConfigurationBuilder authentication = builder.authentication();
if (!authentication.hasSecurityRealm()) {
authentication.securityRealm(securityRealmName);
}
ServerSecurityRealm securityRealm = security.realms().getRealm(authentication.securityRealm()).serverSecurityRealm();
// Only add implicit mechanisms if the user has not set any explicitly
if (!authentication.hasMechanisms()) {
String serverPrincipal = null;
for (KerberosSecurityFactoryConfiguration identity : securityRealm.getServerIdentities().kerberosConfigurations()) {
if (identity.getPrincipal().startsWith("HTTP/")) {
authentication
.enable()
.addMechanisms("SPNEGO");
serverPrincipal = identity.getPrincipal();
}
Server.log.debugf("Enabled SPNEGO authentication for HTTP using principal '%s'", identity.getPrincipal());
}
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.TOKEN)) {
authentication
.enable()
.addMechanisms("BEARER_TOKEN");
Server.log.debug("Enabled BEARER_TOKEN for HTTP");
}
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.TRUST)) {
authentication
.enable()
.addMechanisms("CLIENT_CERT");
Server.log.debug("Enabled CLIENT_CERT for HTTP");
}
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.PASSWORD_HASHED)) {
authentication
.enable()
.addMechanisms("DIGEST");
Server.log.debug("Enabled DIGEST for HTTP");
// Only enable PLAIN if encryption is on
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.ENCRYPT)) {
authentication
.enable()
.addMechanisms("BASIC");
Server.log.debug("Enabled BASIC for HTTP");
}
}
authentication.authenticator(new ElytronHTTPAuthenticator(authentication.securityRealm(), serverPrincipal, authentication.mechanisms()));
}
}
private ProtocolServerConfigurationBuilder<?, ?, ?> enableImplicitAuthentication(SecurityConfiguration security, String securityRealmName, RespServerConfigurationBuilder builder) {
// Set the security realm only if it has not been set already
RespAuthenticationConfigurationBuilder authentication = builder.authentication();
if (!authentication.hasSecurityRealm()) {
authentication.securityRealm(securityRealmName);
}
boolean authSupported = false;
ServerSecurityRealm securityRealm = security.realms().getRealm(authentication.securityRealm()).serverSecurityRealm();
ElytronRESPAuthenticator respAuthenticator = new ElytronRESPAuthenticator();
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.PASSWORD_PLAIN)) {
respAuthenticator.withUsernamePasswordAuth(new ElytronUsernamePasswordAuthenticator(authentication.securityRealm()));
authSupported = true;
}
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.TRUST)) {
respAuthenticator.withClientCertAuth(new RespClientCertAuthenticator(authentication.securityRealm()));
authSupported = true;
}
if (!authSupported) {
if (builder.implicitConnector()) {
// The connector was added implicitly, but the security realm cannot support it. Remove it.
return null;
} else {
throw Server.log.respEndpointRequiresRealmWithPasswordOrTrustore();
}
}
authentication.authenticator(respAuthenticator);
return builder;
}
private ProtocolServerConfigurationBuilder<?, ?, ?> enableImplicitAuthentication(SecurityConfiguration security, String securityRealmName, MemcachedServerConfigurationBuilder builder) {
// Set the security realm only if it has not been set already
MemcachedAuthenticationConfigurationBuilder authentication = builder.authentication();
if (!authentication.hasSecurityRealm()) {
authentication.securityRealm(securityRealmName);
}
ServerSecurityRealm securityRealm = security.realms().getRealm(authentication.securityRealm()).serverSecurityRealm();
MemcachedProtocol protocol = builder.protocol();
// Only add implicit mechanisms if the user has not set any explicitly
if (protocol.isBinary()) {
enableSaslAuthentication(authentication, authentication.sasl(), securityRealm, "memcached/", "Memcached");
}
if (protocol.isText()) {
if (securityRealm.hasFeature(ServerSecurityRealm.Feature.PASSWORD_PLAIN)) {
authentication.text().authenticator(new ElytronUsernamePasswordAuthenticator(authentication.securityRealm()));
} else {
if (builder.implicitConnector()) {
// The connector was added implicitly, but the security realm cannot support it. Remove it.
return null;
} else {
throw Server.log.memcachedTextEndpointRequiresRealmWithPassword();
}
}
}
return builder;
}
}
| 16,844
| 49.585586
| 205
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/endpoint/EndpointConfiguration.java
|
package org.infinispan.server.configuration.endpoint;
import java.util.List;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.router.configuration.SinglePortRouterConfiguration;
/**
* @since 12.0
*/
public class EndpointConfiguration extends ConfigurationElement<EndpointConfiguration> {
static final AttributeDefinition<String> SOCKET_BINDING = AttributeDefinition.builder(Attribute.SOCKET_BINDING, null, String.class).build();
static final AttributeDefinition<String> SECURITY_REALM = AttributeDefinition.builder(Attribute.SECURITY_REALM, null, String.class).build();
static final AttributeDefinition<Boolean> ADMIN = AttributeDefinition.builder(Attribute.ADMIN, true, Boolean.class).build();
static final AttributeDefinition<Boolean> METRICS_AUTH = AttributeDefinition.builder(Attribute.METRICS_AUTH, true, Boolean.class).build();
private final List<ProtocolServerConfiguration<?, ?>> connectors;
private final SinglePortRouterConfiguration singlePort;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(EndpointConfiguration.class, SOCKET_BINDING, SECURITY_REALM, ADMIN, METRICS_AUTH);
}
EndpointConfiguration(AttributeSet attributes,
List<ProtocolServerConfiguration<?, ?>> connectors,
SinglePortRouterConfiguration singlePort) {
super(Element.ENDPOINTS, attributes);
this.connectors = connectors;
this.singlePort = singlePort;
}
public SinglePortRouterConfiguration singlePortRouter() {
return singlePort;
}
public List<ProtocolServerConfiguration<?, ?>> connectors() {
return connectors;
}
public boolean admin() {
return attributes.attribute(ADMIN).get();
}
public boolean metricsAuth() {
return attributes.attribute(METRICS_AUTH).get();
}
public String socketBinding() {
return attributes.attribute(SOCKET_BINDING).get();
}
}
| 2,316
| 40.375
| 143
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/endpoint/EndpointsConfiguration.java
|
package org.infinispan.server.configuration.endpoint;
import java.util.List;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.configuration.Attribute;
/**
* Holds configuration related to endpoints
* @author Tristan Tarrant
* @since 12.0
*/
public class EndpointsConfiguration {
static final AttributeDefinition<String> SOCKET_BINDING = AttributeDefinition.builder(Attribute.SOCKET_BINDING, null, String.class).build();
static final AttributeDefinition<String> SECURITY_REALM = AttributeDefinition.builder(Attribute.SECURITY_REALM, null, String.class).build();
private final List<EndpointConfiguration> endpoints;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(EndpointsConfiguration.class, SOCKET_BINDING, SECURITY_REALM);
}
private final AttributeSet attributes;
EndpointsConfiguration(AttributeSet attributes, List<EndpointConfiguration> endpoints) {
this.attributes = attributes.checkProtection();
this.endpoints = endpoints;
}
public AttributeSet attributes() {
return attributes;
}
public String securityRealm() {
return attributes.attribute(SECURITY_REALM).get();
}
public String socketBinding() {
return attributes.attribute(SOCKET_BINDING).get();
}
public List<EndpointConfiguration> endpoints() {
return endpoints;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EndpointsConfiguration that = (EndpointsConfiguration) o;
return attributes.equals(that.attributes);
}
@Override
public int hashCode() {
return attributes.hashCode();
}
@Override
public String toString() {
return "EndpointConfiguration{" +
"attributes=" + attributes +
'}';
}
}
| 1,982
| 27.73913
| 143
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/endpoint/SinglePortServerConfigurationBuilder.java
|
package org.infinispan.server.configuration.endpoint;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.core.configuration.AuthenticationConfigurationBuilder;
import org.infinispan.server.core.configuration.NoAuthenticationConfiguration;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationBuilder;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.router.configuration.SinglePortRouterConfiguration;
import org.infinispan.server.router.configuration.builder.ConfigurationBuilderParent;
import org.infinispan.server.router.configuration.builder.HotRodRouterBuilder;
import org.infinispan.server.router.configuration.builder.RestRouterBuilder;
import org.infinispan.server.router.configuration.builder.RoutingBuilder;
import org.infinispan.server.router.configuration.builder.SinglePortRouterBuilder;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class SinglePortServerConfigurationBuilder extends ProtocolServerConfigurationBuilder<SinglePortRouterConfiguration, SinglePortServerConfigurationBuilder, NoAuthenticationConfiguration> implements ConfigurationBuilderParent {
private final RoutingBuilder routing = new RoutingBuilder(this);
private final HotRodRouterBuilder hotRodRouter = new HotRodRouterBuilder(this);
private final RestRouterBuilder restRouter = new RestRouterBuilder(this);
private final SinglePortRouterBuilder singlePortRouter = new SinglePortRouterBuilder(this);
public SinglePortServerConfigurationBuilder() {
super(HotRodServer.DEFAULT_HOTROD_PORT, SinglePortRouterConfiguration.attributeDefinitionSet());
singlePortRouter.enabled(true);
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Override
public SinglePortServerConfigurationBuilder self() {
return this;
}
@Override
public SinglePortRouterConfiguration create() {
return new SinglePortRouterConfiguration(attributes.protect(), ssl.create(), ipFilter.create());
}
@Override
public void validate() {
super.validate();
}
public SinglePortRouterConfiguration build(boolean validate) {
if (validate) {
validate();
}
return create();
}
@Override
public AuthenticationConfigurationBuilder<NoAuthenticationConfiguration> authentication() {
throw new UnsupportedOperationException();
}
@Override
public SinglePortRouterConfiguration build() {
return build(true);
}
@Override
public RoutingBuilder routing() {
return routing;
}
@Override
public HotRodRouterBuilder hotrod() {
return hotRodRouter;
}
@Override
public RestRouterBuilder rest() {
return restRouter;
}
@Override
public SinglePortRouterBuilder singlePort() {
return singlePortRouter;
}
public void applyConfigurationToProtocol(ProtocolServerConfigurationBuilder<?, ?, ?> builder) {
if (attributes.attribute(ProtocolServerConfiguration.HOST).isModified()) {
builder.host(attributes.attribute(ProtocolServerConfiguration.HOST).get());
}
if (attributes.attribute(ProtocolServerConfiguration.PORT).isModified()) {
builder.port(attributes.attribute(ProtocolServerConfiguration.PORT).get());
}
builder.startTransport(false);
}
}
| 3,478
| 33.79
| 232
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/endpoint/EndpointsConfigurationBuilder.java
|
package org.infinispan.server.configuration.endpoint;
import static org.infinispan.server.configuration.endpoint.EndpointsConfiguration.SECURITY_REALM;
import static org.infinispan.server.configuration.endpoint.EndpointsConfiguration.SOCKET_BINDING;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.ServerConfigurationBuilder;
import org.infinispan.server.configuration.SocketBindingsConfiguration;
import org.infinispan.server.configuration.security.SecurityConfiguration;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
public class EndpointsConfigurationBuilder implements Builder<EndpointsConfiguration> {
private final AttributeSet attributes;
private final ServerConfigurationBuilder server;
private final Map<String, EndpointConfigurationBuilder> endpoints = new LinkedHashMap<>(2);
private EndpointConfigurationBuilder current;
public EndpointsConfigurationBuilder(ServerConfigurationBuilder server) {
this.server = server;
attributes = EndpointsConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public EndpointsConfigurationBuilder socketBinding(String socketBinding) {
attributes.attribute(SOCKET_BINDING).set(socketBinding);
return this;
}
public EndpointsConfigurationBuilder securityRealm(String securityRealm) {
attributes.attribute(SECURITY_REALM).set(securityRealm);
return this;
}
public EndpointConfigurationBuilder addEndpoint(String socketBindingName) {
if (endpoints.remove(socketBindingName) != null) {
Server.log.endpointSocketBindingOverride(socketBindingName);
}
EndpointConfigurationBuilder builder = new EndpointConfigurationBuilder(server, socketBindingName);
endpoints.put(socketBindingName, builder);
this.current = builder;
return builder;
}
public EndpointConfigurationBuilder current() {
return current;
}
public Map<String, EndpointConfigurationBuilder> endpoints() {
return endpoints;
}
@Override
public EndpointsConfiguration create() {
throw new UnsupportedOperationException();
}
public EndpointsConfiguration create(GlobalConfigurationBuilder builder, SocketBindingsConfiguration bindingsConfiguration, SecurityConfiguration securityConfiguration) {
List<EndpointConfiguration> list = endpoints.values().stream()
.map(e -> e.create(bindingsConfiguration, securityConfiguration)).collect(Collectors.toList());
// When authz is enabled, ensure that at least one endpoint has authn, otherwise the server will be useless.
// This can only be done after implicit settings have been applied
if (builder.security().authorization().isEnabled()) {
for (EndpointConfiguration endpoint : list) {
for (ProtocolServerConfiguration<?, ?> connector : endpoint.connectors()) {
if (connector.authentication().enabled()) {
return new EndpointsConfiguration(attributes.protect(), list);
}
}
}
throw Server.log.authorizationWithoutAuthentication();
}
return new EndpointsConfiguration(attributes.protect(), list);
}
@Override
public EndpointsConfigurationBuilder read(EndpointsConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
endpoints.clear();
return this;
}
@Override
public void validate() {
for (EndpointConfigurationBuilder endpoint : endpoints.values()) {
endpoint.validate();
}
}
}
| 4,031
| 37.769231
| 173
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/memcached/Element.java
|
package org.infinispan.server.configuration.memcached;
import java.util.HashMap;
import java.util.Map;
/**
* @author Tristan Tarrant
* @since 10.0
*/
public enum Element {
//must be first
UNKNOWN(null),
MEMCACHED_CONNECTOR,
AUTHENTICATION,
ENCRYPTION,
SASL;
private static final Map<String, Element> ELEMENTS;
static {
final Map<String, Element> map = new HashMap<>(8);
for (Element element : values()) {
final String name = element.name;
if (name != null) {
map.put(name, element);
}
}
ELEMENTS = map;
}
private final String name;
Element(final String name) {
this.name = name;
}
Element() {
this.name = name().toLowerCase().replace('_', '-');
}
public static Element forName(final String localName) {
final Element element = ELEMENTS.get(localName);
return element == null ? UNKNOWN : element;
}
@Override
public String toString() {
return name;
}
}
| 1,015
| 18.538462
| 58
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/memcached/Attribute.java
|
package org.infinispan.server.configuration.memcached;
import java.util.HashMap;
import java.util.Map;
/**
* @author Tristan Tarrant
* @since 10.0
*/
public enum Attribute {
UNKNOWN(null), // must be first
CACHE,
CACHE_CONTAINER,
CLIENT_ENCODING,
IDLE_TIMEOUT,
IO_THREADS,
NAME,
PROTOCOL,
SECURITY_REALM,
SOCKET_BINDING;
private static final Map<String, Attribute> ATTRIBUTES;
static {
final Map<String, Attribute> map = new HashMap<>(64);
for (Attribute attribute : values()) {
final String name = attribute.name;
if (name != null) {
map.put(name, attribute);
}
}
ATTRIBUTES = map;
}
private final String name;
Attribute(final String name) {
this.name = name;
}
Attribute() {
this.name = name().toLowerCase().replace('_', '-');
}
public static Attribute forName(String localName) {
final Attribute attribute = ATTRIBUTES.get(localName);
return attribute == null ? UNKNOWN : attribute;
}
@Override
public String toString() {
return name;
}
}
| 1,117
| 18.964286
| 60
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/memcached/MemcachedServerConfigurationParser.java
|
package org.infinispan.server.configuration.memcached;
import static org.infinispan.server.configuration.ServerConfigurationParser.parseSasl;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ConfigurationParser;
import org.infinispan.configuration.parsing.Namespace;
import org.infinispan.configuration.parsing.Namespaces;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.ServerConfigurationBuilder;
import org.infinispan.server.configuration.ServerConfigurationParser;
import org.infinispan.server.core.configuration.EncryptionConfigurationBuilder;
import org.infinispan.server.memcached.configuration.MemcachedAuthenticationConfigurationBuilder;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder;
import org.infinispan.server.security.ElytronSASLAuthenticator;
import org.infinispan.server.security.ElytronUsernamePasswordAuthenticator;
import org.kohsuke.MetaInfServices;
import org.wildfly.security.sasl.WildFlySasl;
/**
* Server endpoint configuration parser for memcached
*
* @author Tristan Tarrant
* @since 9.2
*/
@MetaInfServices
@Namespaces({
@Namespace(root = "memcached-connector"),
@Namespace(uri = "urn:infinispan:server:*", root = "memcached-connector"),
})
public class MemcachedServerConfigurationParser implements ConfigurationParser {
private static final org.infinispan.util.logging.Log coreLog = org.infinispan.util.logging.LogFactory.getLog(ServerConfigurationParser.class);
@Override
public void readElement(ConfigurationReader reader, ConfigurationBuilderHolder holder)
{
if (!holder.inScope(ServerConfigurationParser.ENDPOINTS_SCOPE)) {
throw coreLog.invalidScope(ServerConfigurationParser.ENDPOINTS_SCOPE, holder.getScope());
}
GlobalConfigurationBuilder builder = holder.getGlobalConfigurationBuilder();
Element element = Element.forName(reader.getLocalName());
switch (element) {
case MEMCACHED_CONNECTOR: {
ServerConfigurationBuilder serverBuilder = builder.module(ServerConfigurationBuilder.class);
if (serverBuilder != null) {
parseMemcached(reader, serverBuilder, serverBuilder.endpoints().current().addConnector(MemcachedServerConfigurationBuilder.class));
} else {
throw ParseUtils.unexpectedElement(reader);
}
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
@Override
public Namespace[] getNamespaces() {
return ParseUtils.getNamespaceAnnotations(getClass());
}
private void parseMemcached(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, MemcachedServerConfigurationBuilder builder) {
boolean dedicatedSocketBinding = false;
String securityRealm = null;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case CACHE: {
builder.cache(value);
break;
}
case CACHE_CONTAINER: {
break;
}
case CLIENT_ENCODING: {
builder.clientEncoding(MediaType.fromString(value));
break;
}
case IDLE_TIMEOUT: {
builder.idleTimeout(Integer.parseInt(value));
break;
}
case IO_THREADS: {
builder.ioThreads(Integer.parseInt(value));
break;
}
case NAME: {
builder.name(value);
break;
}
case PROTOCOL: {
builder.protocol(ParseUtils.parseEnum(reader, i, MemcachedProtocol.class, value));
break;
}
case SECURITY_REALM: {
builder.authentication().securityRealm(value);
break;
}
case SOCKET_BINDING: {
builder.socketBinding(value);
builder.startTransport(true);
dedicatedSocketBinding = true;
break;
}
default: {
ServerConfigurationParser.parseCommonConnectorAttributes(reader, i, serverBuilder, builder);
}
}
}
if (!dedicatedSocketBinding) {
builder.socketBinding(serverBuilder.endpoints().current().singlePort().socketBinding()).startTransport(false);
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case AUTHENTICATION: {
parseAuthentication(reader, serverBuilder, builder.authentication().enable(), securityRealm);
break;
}
case ENCRYPTION: {
if (!dedicatedSocketBinding) {
throw Server.log.cannotConfigureProtocolEncryptionUnderSinglePort();
}
parseEncryption(reader, serverBuilder, builder.encryption(), securityRealm);
break;
}
default: {
ServerConfigurationParser.parseCommonConnectorElements(reader, builder);
}
}
}
}
private void parseAuthentication(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, MemcachedAuthenticationConfigurationBuilder builder, String securityRealm) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
org.infinispan.server.hotrod.configuration.Attribute attribute = org.infinispan.server.hotrod.configuration.Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case SECURITY_REALM: {
securityRealm = value;
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (securityRealm == null) {
securityRealm = serverBuilder.endpoints().current().securityRealm();
}
if (securityRealm == null) {
throw Server.log.authenticationWithoutSecurityRealm();
}
// Automatically set the digest realm name. It can be overridden by the user
builder.sasl().addMechProperty(WildFlySasl.REALM_LIST, securityRealm);
String serverPrincipal = null;
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case SASL: {
serverPrincipal = parseSasl(reader, builder.sasl());
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
builder.securityRealm(securityRealm);
builder.sasl().authenticator(new ElytronSASLAuthenticator(securityRealm, serverPrincipal, builder.sasl().mechanisms()));
builder.text().authenticator(new ElytronUsernamePasswordAuthenticator(securityRealm));
}
private void parseEncryption(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, EncryptionConfigurationBuilder encryption, String securityRealmName) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
org.infinispan.server.configuration.rest.Attribute attribute = org.infinispan.server.configuration.rest.Attribute.forName(reader.getAttributeName(i));
String value = reader.getAttributeValue(i);
switch (attribute) {
case REQUIRE_SSL_CLIENT_AUTH: {
encryption.requireClientAuth(Boolean.parseBoolean(value));
break;
}
case SECURITY_REALM: {
securityRealmName = value;
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (securityRealmName == null) {
throw Server.log.encryptionWithoutSecurityRealm();
} else {
encryption.realm(securityRealmName).sslContext(serverBuilder.serverSSLContextSupplier(securityRealmName));
}
ParseUtils.requireNoContent(reader);
}
}
| 8,853
| 40.568075
| 182
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/resp/Element.java
|
package org.infinispan.server.configuration.resp;
import java.util.HashMap;
import java.util.Map;
/**
* @author William Burns
* @since 14.0
*/
public enum Element {
//must be first
UNKNOWN(null),
RESP_CONNECTOR,
AUTHENTICATION,
ENCRYPTION;
private static final Map<String, Element> ELEMENTS;
static {
final Map<String, Element> map = new HashMap<>(8);
for (Element element : values()) {
final String name = element.name;
if (name != null) {
map.put(name, element);
}
}
ELEMENTS = map;
}
private final String name;
Element(final String name) {
this.name = name;
}
Element() {
this.name = name().toLowerCase().replace('_', '-');
}
public static Element forName(final String localName) {
final Element element = ELEMENTS.get(localName);
return element == null ? UNKNOWN : element;
}
@Override
public String toString() {
return name;
}
}
| 994
| 18.509804
| 58
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/resp/RespServerConfigurationParser.java
|
package org.infinispan.server.configuration.resp;
import static org.infinispan.commons.util.StringPropertyReplacer.replaceProperties;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ConfigurationParser;
import org.infinispan.configuration.parsing.Namespace;
import org.infinispan.configuration.parsing.Namespaces;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.ServerConfigurationBuilder;
import org.infinispan.server.configuration.ServerConfigurationParser;
import org.infinispan.server.configuration.endpoint.EndpointConfigurationBuilder;
import org.infinispan.server.core.configuration.EncryptionConfigurationBuilder;
import org.infinispan.server.resp.configuration.RespAuthenticationConfigurationBuilder;
import org.infinispan.server.resp.configuration.RespServerConfigurationBuilder;
import org.infinispan.server.security.ElytronUsernamePasswordAuthenticator;
import org.infinispan.server.security.ElytronRESPAuthenticator;
import org.infinispan.server.security.RespClientCertAuthenticator;
import org.infinispan.util.logging.Log;
import org.infinispan.util.logging.LogFactory;
import org.kohsuke.MetaInfServices;
/**
* Server endpoint configuration parser for resp protocol
*
* @author William Burns
* @since 14.0
*/
@MetaInfServices
@Namespaces({
@Namespace(root = "resp-connector"),
@Namespace(uri = "urn:infinispan:server:*", root = "resp-connector"),
})
public class RespServerConfigurationParser implements ConfigurationParser {
private static final Log coreLog = LogFactory.getLog(ServerConfigurationParser.class);
@Override
public void readElement(ConfigurationReader reader, ConfigurationBuilderHolder holder) {
if (!holder.inScope(ServerConfigurationParser.ENDPOINTS_SCOPE)) {
throw coreLog.invalidScope(ServerConfigurationParser.ENDPOINTS_SCOPE, holder.getScope());
}
GlobalConfigurationBuilder builder = holder.getGlobalConfigurationBuilder();
Element element = Element.forName(reader.getLocalName());
switch (element) {
case RESP_CONNECTOR: {
ServerConfigurationBuilder serverBuilder = builder.module(ServerConfigurationBuilder.class);
if (serverBuilder != null) {
parseResp(reader, serverBuilder);
} else {
throw ParseUtils.unexpectedElement(reader);
}
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
@Override
public Namespace[] getNamespaces() {
return ParseUtils.getNamespaceAnnotations(getClass());
}
private void parseResp(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder) {
boolean dedicatedSocketBinding = false;
String securityRealm = null;
EndpointConfigurationBuilder endpoint = serverBuilder.endpoints().current();
RespServerConfigurationBuilder builder = endpoint.addConnector(RespServerConfigurationBuilder.class);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = replaceProperties(reader.getAttributeValue(i));
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case CACHE: {
builder.defaultCacheName(value);
break;
}
case NAME: {
builder.name(value);
break;
}
case SOCKET_BINDING: {
builder.socketBinding(value);
builder.startTransport(true);
dedicatedSocketBinding = true;
break;
}
case SECURITY_REALM: {
securityRealm = value;
}
default: {
ServerConfigurationParser.parseCommonConnectorAttributes(reader, i, serverBuilder, builder);
}
}
}
if (!dedicatedSocketBinding) {
builder.socketBinding(endpoint.singlePort().socketBinding()).startTransport(false);
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case AUTHENTICATION: {
parseAuthentication(reader, serverBuilder, builder.authentication().enable(), securityRealm);
break;
}
case ENCRYPTION: {
if (!dedicatedSocketBinding) {
throw Server.log.cannotConfigureProtocolEncryptionUnderSinglePort();
}
parseEncryption(reader, serverBuilder, builder.encryption(), securityRealm);
break;
}
default: {
ServerConfigurationParser.parseCommonConnectorElements(reader, builder);
}
}
}
}
private void parseAuthentication(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, RespAuthenticationConfigurationBuilder builder, String securityRealmName) {
if (securityRealmName == null) {
securityRealmName = serverBuilder.endpoints().current().securityRealm();
}
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case SECURITY_REALM: {
builder.securityRealm(value);
securityRealmName = value;
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
if (securityRealmName == null) {
throw Server.log.authenticationWithoutSecurityRealm();
}
ElytronRESPAuthenticator authenticator = new ElytronRESPAuthenticator();
authenticator.withUsernamePasswordAuth(new ElytronUsernamePasswordAuthenticator(securityRealmName));
authenticator.withClientCertAuth(new RespClientCertAuthenticator(securityRealmName));
builder.authenticator(authenticator);
}
private void parseEncryption(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, EncryptionConfigurationBuilder encryption, String securityRealmName) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
org.infinispan.server.configuration.rest.Attribute attribute = org.infinispan.server.configuration.rest.Attribute.forName(reader.getAttributeName(i));
String value = reader.getAttributeValue(i);
switch (attribute) {
case REQUIRE_SSL_CLIENT_AUTH: {
encryption.requireClientAuth(Boolean.parseBoolean(value));
break;
}
case SECURITY_REALM: {
securityRealmName = value;
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
if (securityRealmName == null) {
throw Server.log.encryptionWithoutSecurityRealm();
} else {
encryption.realm(securityRealmName).sslContext(serverBuilder.serverSSLContextSupplier(securityRealmName));
}
ParseUtils.requireNoContent(reader);
}
}
| 7,684
| 40.540541
| 181
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/resp/Attribute.java
|
package org.infinispan.server.configuration.resp;
import java.util.HashMap;
import java.util.Map;
/**
* @author William Burns
* @since 14.0
*/
public enum Attribute {
UNKNOWN(null), // must be first
CACHE,
NAME,
SECURITY_REALM,
SOCKET_BINDING;
private static final Map<String, Attribute> ATTRIBUTES;
static {
final Map<String, Attribute> map = new HashMap<>(64);
for (Attribute attribute : values()) {
final String name = attribute.name;
if (name != null) {
map.put(name, attribute);
}
}
ATTRIBUTES = map;
}
private final String name;
Attribute(final String name) {
this.name = name;
}
Attribute() {
this.name = name().toLowerCase().replace('_', '-');
}
public static Attribute forName(String localName) {
final Attribute attribute = ATTRIBUTES.get(localName);
return attribute == null ? UNKNOWN : attribute;
}
@Override
public String toString() {
return name;
}
}
| 1,025
| 19.117647
| 60
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/ServerSecurityRealm.java
|
package org.infinispan.server.security;
import java.util.EnumSet;
import java.util.function.Supplier;
import org.infinispan.server.configuration.security.ServerIdentitiesConfiguration;
import org.wildfly.security.auth.server.MechanismConfiguration;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ServerSecurityRealm {
private final String name;
private final SecurityDomain securityDomain;
private final Supplier<Boolean> httpChallengeReadiness;
private final ServerIdentitiesConfiguration serverIdentities;
private final EnumSet<Feature> features;
public ServerSecurityRealm(String name, SecurityDomain securityDomain, Supplier<Boolean> httpChallengeReadiness, ServerIdentitiesConfiguration serverIdentities, EnumSet<Feature> features) {
this.name = name;
this.securityDomain = securityDomain;
this.httpChallengeReadiness = httpChallengeReadiness;
this.serverIdentities = serverIdentities;
this.features = features;
}
public String getName() {
return name;
}
public boolean isReadyForHttpChallenge() {
return httpChallengeReadiness.get();
}
public SecurityDomain getSecurityDomain() {
return securityDomain;
}
public void applyServerCredentials(MechanismConfiguration.Builder mechConfigurationBuilder, String serverPrincipal) {
if (serverPrincipal != null) {
CredentialSource credentialSource = serverIdentities.getCredentialSource(serverPrincipal);
mechConfigurationBuilder.setServerCredentialSource(credentialSource);
}
}
public ServerIdentitiesConfiguration getServerIdentities() {
return serverIdentities;
}
public boolean hasFeature(Feature feature) {
return features.contains(feature);
}
@Override
public String toString() {
return "ServerSecurityRealm{" +
"name='" + name + '\'' +
", features=" + features +
'}';
}
public enum Feature {
PASSWORD_PLAIN, PASSWORD_HASHED, TOKEN, TRUST, ENCRYPT
}
}
| 2,194
| 30.811594
| 192
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/HttpServerResponseAdapter.java
|
package org.infinispan.server.security;
import java.io.OutputStream;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.RestResponseException;
import org.wildfly.security.http.HttpAuthenticationException;
import org.wildfly.security.http.HttpServerCookie;
import org.wildfly.security.http.HttpServerMechanismsResponder;
import org.wildfly.security.http.HttpServerResponse;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class HttpServerResponseAdapter implements HttpServerResponse {
private final NettyRestResponse.Builder builder;
private HttpServerResponseAdapter(NettyRestResponse.Builder responseBuilder) {
this.builder = responseBuilder;
}
public static void adapt(HttpServerMechanismsResponder responder, NettyRestResponse.Builder responseBuilder) {
try {
HttpServerResponseAdapter response = new HttpServerResponseAdapter(responseBuilder);
if (responder != null) {
responder.sendResponse(response);
}
response.builder.build();
} catch (HttpAuthenticationException e) {
throw new RestResponseException(e);
}
}
@Override
public void addResponseHeader(String headerName, String headerValue) {
builder.header(headerName, headerValue);
}
@Override
public void setStatusCode(int statusCode) {
builder.status(statusCode);
}
@Override
public void setResponseCookie(HttpServerCookie cookie) {
StringBuilder value = new StringBuilder();
value.append(cookie.getName());
value.append('=');
value.append(cookie.getValue());
if (cookie.isHttpOnly()) {
value.append("; HttpOnly");
}
if (cookie.isSecure()) {
value.append("; Secure");
}
if (cookie.getDomain() != null) {
value.append("; Domain=").append(cookie.getDomain());
}
if (cookie.getPath() != null) {
value.append("; Path=").append(cookie.getPath());
}
builder.header("Set-Cookie", value.toString());
}
@Override
public OutputStream getOutputStream() {
return null;
}
@Override
public boolean forward(String path) {
return false;
}
}
| 2,237
| 28.447368
| 113
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/ElytronPasswordProviderSupplier.java
|
package org.infinispan.server.security;
import java.security.Provider;
import java.util.function.Supplier;
import org.wildfly.security.password.WildFlyElytronPasswordProvider;
/**
* @since 14.0
**/
public class ElytronPasswordProviderSupplier implements Supplier<Provider[]> {
public static final Supplier<Provider[]> INSTANCE = new ElytronPasswordProviderSupplier();
public static final Provider[] PROVIDERS = new Provider[]{WildFlyElytronPasswordProvider.getInstance()};
private ElytronPasswordProviderSupplier() {
}
@Override
public Provider[] get() {
return PROVIDERS;
}
}
| 611
| 25.608696
| 107
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/ElytronRESPAuthenticator.java
|
package org.infinispan.server.security;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ScheduledExecutorService;
import javax.security.auth.Subject;
import javax.security.sasl.SaslException;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.ServerConfiguration;
import org.infinispan.server.core.security.UsernamePasswordAuthenticator;
import org.infinispan.server.resp.authentication.RespAuthenticator;
import org.infinispan.util.concurrent.BlockingManager;
import io.netty.channel.Channel;
public class ElytronRESPAuthenticator implements RespAuthenticator {
private UsernamePasswordAuthenticator usernamePasswordAuthenticator;
private RespClientCertAuthenticator clientCertAuthenticator;
@Override
public CompletionStage<Subject> clientCertAuth(Channel channel) throws SaslException {
if (clientCertAuthenticator == null) {
Server.log.debug("No usernamePasswordAuthenticator configured for RESP");
return CompletableFutures.completedNull();
}
return clientCertAuthenticator.clientCertAuth(channel);
}
@Override
public CompletionStage<Subject> usernamePasswordAuth(String username, char[] password) {
if (usernamePasswordAuthenticator == null) {
Server.log.debug("No usernamePasswordAuthenticator configured for RESP");
return CompletableFutures.completedNull();
}
return usernamePasswordAuthenticator.authenticate(username, password);
}
@Override
public boolean isClientCertAuthEnabled() {
return clientCertAuthenticator != null;
}
public void withUsernamePasswordAuth(UsernamePasswordAuthenticator usernamePasswordAuthenticator) {
this.usernamePasswordAuthenticator = usernamePasswordAuthenticator;
}
public void withClientCertAuth(RespClientCertAuthenticator clientCertAuthenticator) {
this.clientCertAuthenticator = clientCertAuthenticator;
}
void init(ServerConfiguration configuration, BlockingManager blockingManager) {
if (usernamePasswordAuthenticator != null) {
ElytronUsernamePasswordAuthenticator.init(usernamePasswordAuthenticator, configuration, blockingManager);
}
}
void init(ServerConfiguration configuration, ScheduledExecutorService timeoutExecutor) {
if (clientCertAuthenticator != null) {
clientCertAuthenticator.init(configuration, timeoutExecutor);
}
}
}
| 2,505
| 36.402985
| 114
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/PasswordCredentialSource.java
|
package org.infinispan.server.security;
import java.io.IOException;
import java.security.spec.AlgorithmParameterSpec;
import java.util.function.Supplier;
import org.wildfly.security.auth.SupportLevel;
import org.wildfly.security.credential.Credential;
import org.wildfly.security.credential.PasswordCredential;
import org.wildfly.security.credential.source.CredentialSource;
import org.wildfly.security.password.interfaces.ClearPassword;
/**
* @since 14.0
*/
public class PasswordCredentialSource implements CredentialSource, Supplier<CredentialSource> {
private final PasswordCredential credential;
public PasswordCredentialSource(char[] password) {
this(new PasswordCredential(ClearPassword.createRaw(ClearPassword.ALGORITHM_CLEAR, password)));
}
public PasswordCredentialSource(PasswordCredential credential) {
this.credential = credential;
}
@Override
public SupportLevel getCredentialAcquireSupport(Class<? extends Credential> credentialType, String s, AlgorithmParameterSpec algorithmParameterSpec) {
return credentialType == PasswordCredential.class ? SupportLevel.SUPPORTED : SupportLevel.UNSUPPORTED;
}
@Override
public <C extends Credential> C getCredential(Class<C> credentialType, String s, AlgorithmParameterSpec algorithmParameterSpec) throws IOException {
return credentialType.cast(credential.clone());
}
@Override
public CredentialSource get() {
return this;
}
}
| 1,462
| 33.833333
| 153
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/ElytronHTTPAuthenticator.java
|
package org.infinispan.server.security;
import static org.wildfly.security.http.HttpConstants.SECURITY_IDENTITY;
import java.security.Provider;
import java.util.Collection;
import java.util.concurrent.CompletionStage;
import javax.security.auth.Subject;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.rest.RestServer;
import org.infinispan.rest.authentication.RestAuthenticator;
import org.infinispan.rest.configuration.RestServerConfiguration;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.security.GroupPrincipal;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.ServerConfiguration;
import org.infinispan.util.concurrent.BlockingManager;
import org.wildfly.security.auth.server.MechanismConfiguration;
import org.wildfly.security.auth.server.MechanismConfigurationSelector;
import org.wildfly.security.auth.server.MechanismRealmConfiguration;
import org.wildfly.security.auth.server.SecurityIdentity;
import org.wildfly.security.auth.server.http.HttpAuthenticationFactory;
import org.wildfly.security.http.HttpAuthenticationException;
import org.wildfly.security.http.HttpServerAuthenticationMechanism;
import org.wildfly.security.http.HttpServerAuthenticationMechanismFactory;
import org.wildfly.security.http.basic.WildFlyElytronHttpBasicProvider;
import org.wildfly.security.http.bearer.WildFlyElytronHttpBearerProvider;
import org.wildfly.security.http.cert.WildFlyElytronHttpClientCertProvider;
import org.wildfly.security.http.digest.DigestMechanismFactory;
import org.wildfly.security.http.digest.WildFlyElytronHttpDigestProvider;
import org.wildfly.security.http.spnego.WildFlyElytronHttpSpnegoProvider;
import org.wildfly.security.http.util.FilterServerMechanismFactory;
import org.wildfly.security.http.util.SecurityProviderServerMechanismFactory;
import org.wildfly.security.http.util.SetMechanismInformationMechanismFactory;
import io.netty.channel.ChannelHandlerContext;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ElytronHTTPAuthenticator implements RestAuthenticator {
private final String name;
private final String serverPrincipal;
private final Collection<String> mechanisms;
private final Provider[] providers;
private HttpAuthenticationFactory factory;
private ServerSecurityRealm serverSecurityRealm;
private BlockingManager blockingManager;
private RestServerConfiguration configuration;
public ElytronHTTPAuthenticator(String name, String serverPrincipal, Collection<String> mechanisms) {
this.name = name;
this.serverPrincipal = serverPrincipal;
this.mechanisms = mechanisms;
this.providers = new Provider[]{
WildFlyElytronHttpBasicProvider.getInstance(),
WildFlyElytronHttpBearerProvider.getInstance(),
WildFlyElytronHttpDigestProvider.getInstance(),
WildFlyElytronHttpClientCertProvider.getInstance(),
WildFlyElytronHttpSpnegoProvider.getInstance(),
};
}
public static void init(RestServerConfiguration configuration, ServerConfiguration serverConfiguration) {
ElytronHTTPAuthenticator authenticator = (ElytronHTTPAuthenticator) configuration.authentication().authenticator();
if (authenticator != null) {
authenticator.init(serverConfiguration);
}
}
public void init(ServerConfiguration serverConfiguration) {
this.serverSecurityRealm = serverConfiguration.security().realms().getRealm(name).serverSecurityRealm();
HttpAuthenticationFactory.Builder httpBuilder = HttpAuthenticationFactory.builder();
httpBuilder.setSecurityDomain(serverSecurityRealm.getSecurityDomain());
HttpServerAuthenticationMechanismFactory httpServerFactory = new SecurityProviderServerMechanismFactory(providers);
httpServerFactory = new SetMechanismInformationMechanismFactory(new FilterServerMechanismFactory(httpServerFactory, true, mechanisms));
httpBuilder.setFactory(httpServerFactory);
MechanismConfiguration.Builder mechConfigurationBuilder = MechanismConfiguration.builder();
serverSecurityRealm.applyServerCredentials(mechConfigurationBuilder, serverPrincipal);
final MechanismRealmConfiguration.Builder mechRealmBuilder = MechanismRealmConfiguration.builder();
mechRealmBuilder.setRealmName(name);
mechConfigurationBuilder.addMechanismRealm(mechRealmBuilder.build());
httpBuilder.setMechanismConfigurationSelector(MechanismConfigurationSelector.constantSelector(mechConfigurationBuilder.build()));
factory = httpBuilder.build();
}
@Override
public CompletionStage<RestResponse> challenge(RestRequest request, ChannelHandlerContext ctx) {
HttpServerRequestAdapter requestAdapter = new HttpServerRequestAdapter(request, ctx);
return blockingManager.supplyBlocking(() -> {
try {
String authorizationHeader = request.getAuthorizationHeader();
if (authorizationHeader == null) {
for (String name : configuration.authentication().mechanisms()) {
HttpServerAuthenticationMechanism mechanism = factory.createMechanism(name);
mechanism.evaluateRequest(requestAdapter);
extractSubject(request, mechanism);
}
} else {
String mechName = authorizationHeader.substring(0, authorizationHeader.indexOf(' ')).toUpperCase();
if ("BEARER".equals(mechName)) {
mechName = "BEARER_TOKEN";
} else if ("NEGOTIATE".equals(mechName)) {
mechName = "SPNEGO";
}
HttpServerAuthenticationMechanism mechanism = factory.createMechanism(mechName);
if (mechanism == null) {
throw Server.log.unsupportedMechanism(mechName);
}
mechanism.evaluateRequest(requestAdapter);
extractSubject(request, mechanism);
}
return requestAdapter.getResponse();
} catch (Exception e) {
throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
}
}, "auth");
}
private void extractSubject(RestRequest request, HttpServerAuthenticationMechanism mechanism) {
SecurityIdentity securityIdentity = (SecurityIdentity) mechanism.getNegotiatedProperty(SECURITY_IDENTITY);
if (securityIdentity != null) {
Subject subject = new Subject();
subject.getPrincipals().add(securityIdentity.getPrincipal());
securityIdentity.getRoles().forEach(r -> subject.getPrincipals().add(new GroupPrincipal(r)));
request.setSubject(subject);
}
}
public void init(RestServer restServer) {
this.configuration = restServer.getConfiguration();
this.blockingManager = restServer.getBlockingManager();
for (String name : configuration.authentication().mechanisms()) {
try {
factory.createMechanism(name);
} catch (HttpAuthenticationException e) {
throw new CacheConfigurationException("Could not create HTTP authentication mechanism " + name);
}
}
}
@Override
public boolean isReadyForHttpChallenge() {
return serverSecurityRealm.isReadyForHttpChallenge();
}
@Override
public void close() {
// Hack to shutdown the nonce executor
if (Boolean.parseBoolean(System.getProperty(Server.INFINISPAN_ELYTRON_NONCE_SHUTDOWN, "true"))) {
new DigestMechanismFactory().shutdown();
}
factory.shutdownAuthenticationMechanismFactory();
}
}
| 7,722
| 46.67284
| 141
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/ElytronSubjectSaslServer.java
|
package org.infinispan.server.security;
import java.security.Principal;
import java.util.List;
import java.util.Set;
import javax.security.auth.Subject;
import javax.security.sasl.SaslServer;
import org.infinispan.security.GroupPrincipal;
import org.infinispan.server.core.security.sasl.AuthorizingCallbackHandler;
import org.infinispan.server.core.security.sasl.SubjectSaslServer;
import org.wildfly.security.auth.server.SecurityIdentity;
import org.wildfly.security.sasl.WildFlySasl;
/**
* A {@link SaslServer} which, when complete, can return a negotiated property named {@link #SUBJECT} which contains a
* populated {@link Subject} representing the authenticated user.
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
class ElytronSubjectSaslServer extends SubjectSaslServer {
public ElytronSubjectSaslServer(SaslServer delegate, List<Principal> principals, AuthorizingCallbackHandler callbackHandler) {
super(delegate, principals, callbackHandler);
}
@Override
public Object getNegotiatedProperty(String propName) {
if (SUBJECT.equals(propName)) {
if (isComplete()) {
SecurityIdentity identity = (SecurityIdentity) delegate.getNegotiatedProperty(WildFlySasl.SECURITY_IDENTITY);
Subject subject = new Subject();
Set<Principal> principals = subject.getPrincipals();
if (!identity.isAnonymous()) {
principals.add(identity.getPrincipal());
}
identity.getRoles().forEach(role -> principals.add(new GroupPrincipal(role)));
principals.addAll(this.principals);
return subject;
} else {
throw new IllegalStateException("Authentication is not complete");
}
} else {
return delegate.getNegotiatedProperty(propName);
}
}
}
| 1,854
| 36.1
| 129
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/RespClientCertAuthenticator.java
|
package org.infinispan.server.security;
import java.util.Collections;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ScheduledExecutorService;
import javax.security.auth.Subject;
import javax.security.sasl.SaslException;
import javax.security.sasl.SaslServer;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.server.configuration.ServerConfiguration;
import org.infinispan.server.core.security.sasl.SaslAuthenticator;
import org.infinispan.server.core.security.sasl.SubjectSaslServer;
import org.wildfly.security.sasl.util.SaslMechanismInformation;
import io.netty.channel.Channel;
public class RespClientCertAuthenticator {
private final String realmName;
private final ElytronSASLAuthenticator authenticator;
public RespClientCertAuthenticator(String realmName) {
this.realmName = realmName;
authenticator = new ElytronSASLAuthenticator(realmName, null, Collections.singleton(SaslMechanismInformation.Names.EXTERNAL));
}
public CompletionStage<Subject> clientCertAuth(Channel channel) throws SaslException {
SaslServer server = null;
try {
server = SaslAuthenticator.createSaslServer(authenticator, null, channel, SaslMechanismInformation.Names.EXTERNAL, "resp");
if (server == null) {
return CompletableFutures.completedNull();
}
server.evaluateResponse(new byte[0]);
return CompletableFuture.completedFuture((Subject) server.getNegotiatedProperty(SubjectSaslServer.SUBJECT));
} catch (Throwable e) {
throw new RuntimeException(e);
} finally {
if (server != null) {
server.dispose();
}
}
}
public void init(ServerConfiguration configuration, ScheduledExecutorService timeoutExecutor) {
authenticator.init(configuration, timeoutExecutor);
}
}
| 1,936
| 34.87037
| 132
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/HostnameVerificationPolicy.java
|
package org.infinispan.server.security;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
public enum HostnameVerificationPolicy {
ANY((s, sslSession) -> true),
DEFAULT(HttpsURLConnection.getDefaultHostnameVerifier());
private final HostnameVerifier verifier;
HostnameVerificationPolicy(HostnameVerifier verifier) {
this.verifier = verifier;
}
public HostnameVerifier getVerifier() {
return verifier;
}
}
| 473
| 22.7
| 60
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/ElytronJMXAuthenticator.java
|
package org.infinispan.server.security;
import java.io.IOException;
import java.util.function.BiPredicate;
import javax.security.auth.Subject;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
import javax.security.auth.callback.UnsupportedCallbackException;
import org.infinispan.security.GroupPrincipal;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.ServerConfiguration;
import org.infinispan.server.loader.ServerLoginModule;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityIdentity;
import org.wildfly.security.evidence.PasswordGuessEvidence;
/**
* @since 14.0
**/
public class ElytronJMXAuthenticator implements BiPredicate<CallbackHandler, Subject> {
private final SecurityDomain securityDomain;
private ElytronJMXAuthenticator(SecurityDomain securityDomain) {
this.securityDomain = securityDomain;
}
public static void init(ServerConfiguration serverConfiguration) {
BiPredicate<CallbackHandler, Subject> authenticator;
String securityRealm = serverConfiguration.endpoints().securityRealm();
if (securityRealm != null) {
SecurityDomain securityDomain = serverConfiguration.security().realms().realms().get(securityRealm).serverSecurityRealm().getSecurityDomain();
authenticator = new ElytronJMXAuthenticator(securityDomain);
} else {
Server.log.jmxNoDefaultSecurityRealm();
authenticator = (c, s) -> false;
}
ServerLoginModule.setAuthenticator(authenticator);
}
@Override
public boolean test(CallbackHandler callbackHandler, Subject subject) {
NameCallback name = new NameCallback("username");
PasswordCallback password = new PasswordCallback("password", false);
try {
callbackHandler.handle(new Callback[]{name, password});
SecurityIdentity securityIdentity = securityDomain.authenticate(name.getName(), new PasswordGuessEvidence(password.getPassword()));
subject.getPrincipals().add(securityIdentity.getPrincipal());
securityIdentity.getRoles().forEach(r -> subject.getPrincipals().add(new GroupPrincipal(r)));
return true;
} catch (IOException | UnsupportedCallbackException e) {
Server.log.jmxAuthenticationError(e);
return false;
}
}
}
| 2,494
| 40.583333
| 151
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/HttpServerRequestAdapter.java
|
package org.infinispan.server.security;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.URI;
import java.security.cert.Certificate;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLSession;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.wildfly.security.http.HttpAuthenticationException;
import org.wildfly.security.http.HttpScope;
import org.wildfly.security.http.HttpServerCookie;
import org.wildfly.security.http.HttpServerMechanismsResponder;
import org.wildfly.security.http.HttpServerRequest;
import org.wildfly.security.http.Scope;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPipeline;
import io.netty.handler.ssl.SslHandler;
import io.netty.util.AttributeKey;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class HttpServerRequestAdapter implements HttpServerRequest {
private final RestRequest request;
private final ChannelHandlerContext ctx;
private static final AttributeKey<HttpScope> HTTP_SCOPE_ATTACHMENT_KEY = AttributeKey.newInstance(HttpScope.class.getSimpleName());
NettyRestResponse.Builder responseBuilder;
public HttpServerRequestAdapter(RestRequest request, ChannelHandlerContext ctx) {
this.request = request;
this.ctx = ctx;
this.responseBuilder = new NettyRestResponse.Builder();
}
@Override
public List<String> getRequestHeaderValues(String s) {
return request.headers(s);
}
@Override
public String getFirstRequestHeaderValue(String s) {
return request.header(s);
}
@Override
public SSLSession getSSLSession() {
ChannelPipeline pipeline = ctx.pipeline();
SslHandler sslHandler = (SslHandler) pipeline.get(SslHandler.class.getName());
if (sslHandler == null && pipeline.channel().parent() != null) {
sslHandler = (SslHandler) pipeline.channel().parent().pipeline().get(SslHandler.class.getName());
}
return sslHandler != null ? sslHandler.engine().getSession() : null;
}
@Override
public Certificate[] getPeerCertificates() {
SSLSession sslSession = getSSLSession();
try {
return sslSession != null ? sslSession.getPeerCertificates() : new Certificate[0];
} catch (SSLPeerUnverifiedException e) {
throw new RuntimeException(e);
}
}
@Override
public void noAuthenticationInProgress(HttpServerMechanismsResponder responder) {
HttpServerResponseAdapter.adapt(responder, responseBuilder);
}
@Override
public void authenticationInProgress(HttpServerMechanismsResponder responder) {
HttpServerResponseAdapter.adapt(responder, responseBuilder);
}
@Override
public void authenticationComplete(HttpServerMechanismsResponder responder) {
HttpServerResponseAdapter.adapt(responder, responseBuilder);
}
@Override
public void authenticationComplete(HttpServerMechanismsResponder responder, Runnable runnable) {
HttpServerResponseAdapter.adapt(responder, responseBuilder);
}
@Override
public void authenticationFailed(String s, HttpServerMechanismsResponder responder) {
HttpServerResponseAdapter.adapt(responder, responseBuilder);
}
@Override
public void badRequest(HttpAuthenticationException e, HttpServerMechanismsResponder responder) {
HttpServerResponseAdapter.adapt(responder, responseBuilder);
}
@Override
public String getRequestMethod() {
return request.method().name();
}
@Override
public URI getRequestURI() {
return URI.create(request.uri());
}
@Override
public String getRequestPath() {
return request.path();
}
@Override
public Map<String, List<String>> getParameters() {
return request.parameters();
}
@Override
public Set<String> getParameterNames() {
return request.parameters().keySet();
}
@Override
public List<String> getParameterValues(String s) {
return request.parameters().get(s);
}
@Override
public String getFirstParameterValue(String s) {
return request.parameters().get(s).get(0);
}
@Override
public List<HttpServerCookie> getCookies() {
return Collections.emptyList();
}
@Override
public InputStream getInputStream() {
return null;
}
@Override
public InetSocketAddress getSourceAddress() {
return (InetSocketAddress) ctx.channel().remoteAddress();
}
@Override
public boolean suspendRequest() {
return false;
}
@Override
public boolean resumeRequest() {
return false;
}
@Override
public HttpScope getScope(Scope scope) {
switch (scope) {
case CONNECTION:
return getScope(ctx.channel());
case GLOBAL:
return null;
case SSL_SESSION:
return getScope(getSSLSession());
}
return null;
}
@Override
public Collection<String> getScopeIds(Scope scope) {
return null;
}
@Override
public HttpScope getScope(Scope scope, String s) {
return null;
}
public RestResponse getResponse() {
return responseBuilder.build();
}
private HttpScope getScope(Channel channel) {
HttpScope httpScope = (HttpScope) channel.attr(HTTP_SCOPE_ATTACHMENT_KEY).get();
if (httpScope == null) {
synchronized (channel) {
httpScope = (HttpScope) channel.attr(HTTP_SCOPE_ATTACHMENT_KEY).get();
if (httpScope == null) {
final Map<String, Object> storageMap = new HashMap<>();
httpScope = new HttpScope() {
@Override
public boolean exists() {
return true;
}
@Override
public boolean create() {
return false;
}
@Override
public boolean supportsAttachments() {
return true;
}
@Override
public void setAttachment(String key, Object value) {
if (value != null) {
storageMap.put(key, value);
} else {
storageMap.remove(key);
}
}
@Override
public Object getAttachment(String key) {
return storageMap.get(key);
}
};
channel.attr(HTTP_SCOPE_ATTACHMENT_KEY).set(httpScope);
}
}
}
return httpScope;
}
private HttpScope getScope(final SSLSession sslSession) {
if (sslSession == null) {
return null;
}
return new HttpScope() {
@Override
public boolean exists() {
return true;
}
@Override
public boolean create() {
return false;
}
@Override
public boolean supportsAttachments() {
return true;
}
@Override
public void setAttachment(String key, Object value) {
sslSession.putValue(key, value);
}
@Override
public Object getAttachment(String key) {
return sslSession.getValue(key);
}
};
}
}
| 7,660
| 26.458781
| 134
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/KeyStoreUtils.java
|
package org.infinispan.server.security;
import static org.wildfly.security.provider.util.ProviderUtil.findProvider;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.time.Instant;
import java.time.ZonedDateTime;
import java.util.Date;
import java.util.TimeZone;
import javax.security.auth.x500.X500Principal;
import org.wildfly.security.x500.cert.X509CertificateBuilder;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class KeyStoreUtils {
public static void generateSelfSignedCertificate(String keyStoreFileName, String provider, char[] keyStorePassword, char[] keyStoreCertificatePassword, String keyAlias, String host) throws IOException, GeneralSecurityException {
KeyPairGenerator keyGen = provider != null ? KeyPairGenerator.getInstance("RSA", provider) : KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048, new SecureRandom());
KeyPair pair = keyGen.generateKeyPair();
PrivateKey privkey = pair.getPrivate();
X509CertificateBuilder builder = new X509CertificateBuilder();
Date from = new Date();
Date to = new Date(from.getTime() + (1000L * 60L * 60L * 24L * 365L * 10L));
BigInteger sn = new BigInteger(64, new SecureRandom());
builder.setNotValidAfter(ZonedDateTime.ofInstant(Instant.ofEpochMilli(to.getTime()), TimeZone.getDefault().toZoneId()));
builder.setNotValidBefore(ZonedDateTime.ofInstant(Instant.ofEpochMilli(from.getTime()), TimeZone.getDefault().toZoneId()));
builder.setSerialNumber(sn);
X500Principal owner = new X500Principal("CN=" + host);
builder.setSubjectDn(owner);
builder.setIssuerDn(owner);
builder.setPublicKey(pair.getPublic());
builder.setVersion(3);
builder.setSignatureAlgorithmName("SHA256withRSA");
builder.setSigningKey(privkey);
KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
keyStore.load(null, keyStorePassword);
X509Certificate[] chain = new X509Certificate[1];
chain[0] = builder.build();
keyStore.setKeyEntry(keyAlias, pair.getPrivate(), keyStoreCertificatePassword != null ? keyStoreCertificatePassword : keyStorePassword, chain);
try (FileOutputStream stream = new FileOutputStream(keyStoreFileName)) {
keyStore.store(stream, keyStorePassword);
}
}
public static void generateEmptyKeyStore(String keyStoreFileName, char[] keyStorePassword) throws IOException, GeneralSecurityException {
KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
keyStore.load(null, keyStorePassword);
try (FileOutputStream stream = new FileOutputStream(keyStoreFileName)) {
keyStore.store(stream, keyStorePassword);
}
}
public static KeyStore buildFilelessKeyStore(Provider[] providers, String providerName, String type) throws GeneralSecurityException, IOException {
Provider provider = findProvider(providers, providerName, KeyStore.class, type);
KeyStore keyStore = KeyStore.getInstance(type, provider);
keyStore.load(null, null);
return keyStore;
}
}
| 3,455
| 43.307692
| 231
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/ElytronUsernamePasswordAuthenticator.java
|
package org.infinispan.server.security;
import java.util.concurrent.CompletionStage;
import javax.security.auth.Subject;
import org.infinispan.security.GroupPrincipal;
import org.infinispan.server.configuration.ServerConfiguration;
import org.infinispan.server.core.security.UsernamePasswordAuthenticator;
import org.infinispan.server.resp.authentication.RespAuthenticator;
import org.infinispan.server.resp.configuration.RespServerConfiguration;
import org.infinispan.util.concurrent.BlockingManager;
import org.wildfly.security.auth.server.RealmUnavailableException;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityIdentity;
import org.wildfly.security.evidence.PasswordGuessEvidence;
/**
* @since 14.0
**/
public class ElytronUsernamePasswordAuthenticator implements UsernamePasswordAuthenticator {
private final String name;
private SecurityDomain securityDomain;
private BlockingManager blockingManager;
public ElytronUsernamePasswordAuthenticator(String name) {
this.name = name;
}
public static void init(UsernamePasswordAuthenticator authenticator, ServerConfiguration serverConfiguration, BlockingManager blockingManager) {
if (authenticator instanceof ElytronUsernamePasswordAuthenticator) {
((ElytronUsernamePasswordAuthenticator)authenticator).init(serverConfiguration, blockingManager);
}
}
public static void init(RespServerConfiguration configuration, ServerConfiguration serverConfiguration, BlockingManager blockingManager) {
RespAuthenticator authenticator = configuration.authentication().authenticator();
if (authenticator != null) {
((ElytronRESPAuthenticator) authenticator).init(serverConfiguration, blockingManager);
}
}
private void init(ServerConfiguration serverConfiguration, BlockingManager blockingManager) {
securityDomain = serverConfiguration.security().realms().getRealm(name).serverSecurityRealm().getSecurityDomain();
this.blockingManager = blockingManager;
}
@Override
public CompletionStage<Subject> authenticate(String username, char[] password) {
return blockingManager.supplyBlocking(() -> {
try {
SecurityIdentity securityIdentity = securityDomain.authenticate(username, new PasswordGuessEvidence(password));
Subject subject = new Subject();
subject.getPrincipals().add(securityIdentity.getPrincipal());
securityIdentity.getRoles().forEach(r -> subject.getPrincipals().add(new GroupPrincipal(r)));
return subject;
} catch (RealmUnavailableException e) {
throw new RuntimeException(e);
}
}, "elytron-auth");
}
}
| 2,739
| 42.492063
| 147
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/KeycloakRoleDecoder.java
|
package org.infinispan.server.security;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.infinispan.commons.dataconversion.internal.Json;
import org.wildfly.security.authz.Attributes;
import org.wildfly.security.authz.Attributes.Entry;
import org.wildfly.security.authz.AuthorizationIdentity;
import org.wildfly.security.authz.RoleDecoder;
import org.wildfly.security.authz.Roles;
public class KeycloakRoleDecoder implements RoleDecoder {
private static final String CLAIM_REALM_ACCESS = "realm_access";
private static final String CLAIM_RESOURCE_ACCESS = "resource_access";
private static final String CLAIM_ROLES = "roles";
@Override
public Roles decodeRoles(AuthorizationIdentity identity) {
Attributes attributes = identity.getAttributes();
Entry realmAccess = attributes.get(CLAIM_REALM_ACCESS);
Set<String> roleSet = new HashSet<>();
if (realmAccess != null && !realmAccess.isEmpty()) {
String realmAccessValue = realmAccess.get(0);
Json json = Json.read(realmAccessValue);
Json rolesValue = json.at(CLAIM_ROLES);
if (rolesValue != null) {
for (Object role : rolesValue.asList()) {
roleSet.add(role.toString());
}
}
}
Entry resourceAccess = attributes.get(CLAIM_RESOURCE_ACCESS);
if (resourceAccess != null) {
for (String resource : resourceAccess) {
Map<String, Json> resources = Json.read(resource).asJsonMap();
for (String resourceKey : resources.keySet()) {
Json roles = resources.get(resourceKey).at("roles");
if (roles != null) {
for (Object role : roles.asList()) {
roleSet.add(role.toString());
}
}
}
}
}
return Roles.fromSet(roleSet);
}
}
| 1,908
| 32.491228
| 74
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/ElytronSASLAuthenticator.java
|
package org.infinispan.server.security;
import java.security.Principal;
import java.security.Provider;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ScheduledExecutorService;
import javax.security.sasl.SaslException;
import javax.security.sasl.SaslServer;
import org.infinispan.server.configuration.ServerConfiguration;
import org.infinispan.server.core.security.sasl.SaslAuthenticator;
import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration;
import org.infinispan.server.memcached.configuration.MemcachedServerConfiguration;
import org.infinispan.server.resp.authentication.RespAuthenticator;
import org.infinispan.server.resp.configuration.RespServerConfiguration;
import org.wildfly.security.auth.server.MechanismConfiguration;
import org.wildfly.security.auth.server.MechanismConfigurationSelector;
import org.wildfly.security.auth.server.MechanismRealmConfiguration;
import org.wildfly.security.auth.server.sasl.SaslAuthenticationFactory;
import org.wildfly.security.sasl.digest.WildFlyElytronSaslDigestProvider;
import org.wildfly.security.sasl.external.WildFlyElytronSaslExternalProvider;
import org.wildfly.security.sasl.gs2.WildFlyElytronSaslGs2Provider;
import org.wildfly.security.sasl.gssapi.WildFlyElytronSaslGssapiProvider;
import org.wildfly.security.sasl.localuser.WildFlyElytronSaslLocalUserProvider;
import org.wildfly.security.sasl.oauth2.WildFlyElytronSaslOAuth2Provider;
import org.wildfly.security.sasl.plain.WildFlyElytronSaslPlainProvider;
import org.wildfly.security.sasl.scram.WildFlyElytronSaslScramProvider;
import org.wildfly.security.sasl.util.AggregateSaslServerFactory;
import org.wildfly.security.sasl.util.FilterMechanismSaslServerFactory;
import org.wildfly.security.sasl.util.PropertiesSaslServerFactory;
import org.wildfly.security.sasl.util.ProtocolSaslServerFactory;
import org.wildfly.security.sasl.util.SecurityProviderSaslServerFactory;
import org.wildfly.security.sasl.util.ServerNameSaslServerFactory;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ElytronSASLAuthenticator implements SaslAuthenticator {
private final String name;
private final String serverPrincipal;
private final Collection<String> mechanisms;
private SaslAuthenticationFactory saslAuthenticationFactory;
public ElytronSASLAuthenticator(String name, String serverPrincipal, Collection<String> mechanisms) {
this.name = name;
this.serverPrincipal = serverPrincipal;
this.mechanisms = mechanisms;
}
public static void init(HotRodServerConfiguration configuration, ServerConfiguration serverConfiguration, ScheduledExecutorService timeoutExecutor) {
ElytronSASLAuthenticator authenticator = (ElytronSASLAuthenticator) configuration.authentication().sasl().authenticator();
if (authenticator != null) {
authenticator.init(serverConfiguration, timeoutExecutor);
}
}
public static void init(MemcachedServerConfiguration configuration, ServerConfiguration serverConfiguration, ScheduledExecutorService timeoutExecutor) {
ElytronSASLAuthenticator authenticator = (ElytronSASLAuthenticator) configuration.authentication().sasl().authenticator();
if (authenticator != null) {
authenticator.init(serverConfiguration, timeoutExecutor);
}
}
public static void init(RespServerConfiguration configuration, ServerConfiguration serverConfiguration, ScheduledExecutorService timeoutExecutor) {
RespAuthenticator authenticator = configuration.authentication().authenticator();
if (authenticator != null) {
((ElytronRESPAuthenticator) authenticator).init(serverConfiguration, timeoutExecutor);
}
}
public void init(ServerConfiguration serverConfiguration, ScheduledExecutorService timeoutExecutor) {
Provider[] providers = new Provider[]{
WildFlyElytronSaslPlainProvider.getInstance(),
WildFlyElytronSaslDigestProvider.getInstance(),
WildFlyElytronSaslScramProvider.getInstance(),
WildFlyElytronSaslExternalProvider.getInstance(),
WildFlyElytronSaslLocalUserProvider.getInstance(),
WildFlyElytronSaslOAuth2Provider.getInstance(),
WildFlyElytronSaslGssapiProvider.getInstance(),
WildFlyElytronSaslGs2Provider.getInstance()
};
SecurityProviderSaslServerFactory securityProviderSaslServerFactory = new SecurityProviderSaslServerFactory(() -> providers);
ServerSecurityRealm realm = serverConfiguration.security().realms().getRealm(name).serverSecurityRealm();
SaslAuthenticationFactory.Builder builder = SaslAuthenticationFactory.builder();
AggregateSaslServerFactory factory = new AggregateSaslServerFactory(new FilterMechanismSaslServerFactory(securityProviderSaslServerFactory, true, mechanisms));
builder.setFactory(factory);
builder.setSecurityDomain(realm.getSecurityDomain());
MechanismConfiguration.Builder mechConfigurationBuilder = MechanismConfiguration.builder();
realm.applyServerCredentials(mechConfigurationBuilder, serverPrincipal);
final MechanismRealmConfiguration.Builder mechRealmBuilder = MechanismRealmConfiguration.builder();
mechRealmBuilder.setRealmName(name);
mechConfigurationBuilder.addMechanismRealm(mechRealmBuilder.build());
builder.setMechanismConfigurationSelector(MechanismConfigurationSelector.constantSelector(mechConfigurationBuilder.build()));
builder.setScheduledExecutorService(timeoutExecutor);
saslAuthenticationFactory = builder.build();
}
@Override
public SaslServer createSaslServer(String mechanism, List<Principal> principals, String protocol, String serverName, Map<String, String> props) throws SaslException {
SaslServer saslServer = saslAuthenticationFactory.createMechanism(mechanism, factory -> {
factory = new ServerNameSaslServerFactory(factory, serverName);
factory = new ProtocolSaslServerFactory(factory, protocol);
factory = props != null ? new PropertiesSaslServerFactory(factory, props) : factory;
return factory;
});
return saslServer == null ? null : new ElytronSubjectSaslServer(saslServer, principals, null);
}
}
| 6,301
| 54.769912
| 169
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/realm/DistributedSecurityRealm.java
|
package org.infinispan.server.security.realm;
import java.security.Principal;
import java.security.spec.AlgorithmParameterSpec;
import org.wildfly.security.auth.SupportLevel;
import org.wildfly.security.auth.server.RealmIdentity;
import org.wildfly.security.auth.server.RealmUnavailableException;
import org.wildfly.security.auth.server.SecurityRealm;
import org.wildfly.security.authz.AuthorizationIdentity;
import org.wildfly.security.credential.Credential;
import org.wildfly.security.evidence.AlgorithmEvidence;
import org.wildfly.security.evidence.Evidence;
/**
* A realm for authentication and authorization of identities distributed between multiple realms.
*
* @author <a href="mailto:mmazanek@redhat.com">Martin Mazanek</a>
*/
public class DistributedSecurityRealm implements SecurityRealm {
private final SecurityRealm[] securityRealms;
public DistributedSecurityRealm(final SecurityRealm... securityRealms) {
this.securityRealms = securityRealms;
}
@Override
public RealmIdentity getRealmIdentity(final Evidence evidence) throws RealmUnavailableException {
return new EvidenceDistributedIdentity(evidence);
}
@Override
public RealmIdentity getRealmIdentity(final Principal principal) throws RealmUnavailableException {
return new PrincipalDistributedIdentity(principal);
}
@Override
public SupportLevel getCredentialAcquireSupport(final Class<? extends Credential> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
SupportLevel max = SupportLevel.UNSUPPORTED;
for (SecurityRealm r : securityRealms) {
max = SupportLevel.max(max, r.getCredentialAcquireSupport(credentialType, algorithmName, parameterSpec));
}
return max;
}
@Override
public SupportLevel getEvidenceVerifySupport(final Class<? extends Evidence> evidenceType, final String algorithmName) throws RealmUnavailableException {
SupportLevel max = SupportLevel.UNSUPPORTED;
for (SecurityRealm r : securityRealms) {
max = SupportLevel.max(max, r.getEvidenceVerifySupport(evidenceType, algorithmName));
}
return max;
}
final class EvidenceDistributedIdentity implements RealmIdentity {
private final Evidence evidence;
private final String evidenceAlgorithm;
private RealmIdentity currentIdentity = RealmIdentity.NON_EXISTENT;
private int nextRealm = 0;
private EvidenceDistributedIdentity(Evidence evidence) throws RealmUnavailableException {
this.evidence = evidence;
if (evidence instanceof AlgorithmEvidence) {
evidenceAlgorithm = ((AlgorithmEvidence) evidence).getAlgorithm();
} else {
evidenceAlgorithm = null;
}
nextIdentity();
}
private boolean nextIdentity() throws RealmUnavailableException {
currentIdentity.dispose();
if (nextRealm >= securityRealms.length) {
currentIdentity = RealmIdentity.NON_EXISTENT;
return false;
}
if (securityRealms[nextRealm].getEvidenceVerifySupport(evidence.getClass(), evidenceAlgorithm).mayBeSupported()) {
currentIdentity = securityRealms[nextRealm].getRealmIdentity(evidence);
nextRealm++;
if (currentIdentity.getEvidenceVerifySupport(evidence.getClass(), evidenceAlgorithm).isNotSupported()) {
return nextIdentity();
}
} else {
nextRealm++;
return nextIdentity();
}
return true;
}
@Override
public Principal getRealmIdentityPrincipal() {
return currentIdentity.getRealmIdentityPrincipal();
}
@Override
public SupportLevel getCredentialAcquireSupport(final Class<? extends Credential> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
// Identity created from evidence will be verified using the evidence
return SupportLevel.UNSUPPORTED;
}
@Override
public SupportLevel getEvidenceVerifySupport(final Class<? extends Evidence> evidenceType, final String algorithmName) throws RealmUnavailableException {
//as server verifies evidence with same evidence used for creating realm identity, we dont have to look into remaining realms for support (currentIdentity will always support evidence verification, unless none of the possible does)
return currentIdentity.getEvidenceVerifySupport(evidenceType, algorithmName);
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
return null;
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName) throws RealmUnavailableException {
return null;
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType) throws RealmUnavailableException {
return null;
}
@Override
public boolean verifyEvidence(final Evidence evidence) throws RealmUnavailableException {
do {
if (currentIdentity.verifyEvidence(evidence)) {
return true;
}
} while (nextIdentity());
return false;
}
@Override
public boolean exists() throws RealmUnavailableException {
return currentIdentity.exists();
}
@Override
public AuthorizationIdentity getAuthorizationIdentity() throws RealmUnavailableException {
return currentIdentity.getAuthorizationIdentity();
}
@Override
public void dispose() {
currentIdentity.dispose();
}
}
final class PrincipalDistributedIdentity implements RealmIdentity {
private final Principal principal;
private RealmIdentity currentIdentity = RealmIdentity.NON_EXISTENT;
private int nextRealm = 0;
PrincipalDistributedIdentity(Principal principal) throws RealmUnavailableException {
this.principal = principal;
nextIdentity();
}
private boolean nextIdentity() throws RealmUnavailableException {
currentIdentity.dispose();
if (nextRealm >= securityRealms.length) {
currentIdentity = RealmIdentity.NON_EXISTENT;
return false;
}
currentIdentity = securityRealms[nextRealm].getRealmIdentity(principal);
nextRealm++;
if (!currentIdentity.exists()) {
return nextIdentity();
}
return true;
}
@Override
public Principal getRealmIdentityPrincipal() {
return currentIdentity.getRealmIdentityPrincipal();
}
@Override
public SupportLevel getCredentialAcquireSupport(final Class<? extends Credential> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
return currentIdentity.getCredentialAcquireSupport(credentialType, algorithmName, parameterSpec);
}
@Override
public SupportLevel getEvidenceVerifySupport(final Class<? extends Evidence> evidenceType, final String algorithmName) throws RealmUnavailableException {
return currentIdentity.getEvidenceVerifySupport(evidenceType, algorithmName);
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
do {
System.out.printf("Identity= %s credentialType=%s algorithmName=%s parameterSpec=%s", currentIdentity.getRealmIdentityPrincipal(), credentialType, algorithmName, parameterSpec);
C credential = currentIdentity.getCredential(credentialType, algorithmName, parameterSpec);
if (credential != null) {
return credential;
}
} while (nextIdentity());
return null;
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName) throws RealmUnavailableException {
do {
System.out.printf("Identity= %s credentialType=%s algorithmName=%s", currentIdentity.getRealmIdentityPrincipal(), credentialType, algorithmName);
C credential = currentIdentity.getCredential(credentialType, algorithmName);
if (credential != null) {
return credential;
}
} while (nextIdentity());
return null;
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType) throws RealmUnavailableException {
do {
System.out.printf("Identity= %s credentialType=%s", currentIdentity.getRealmIdentityPrincipal(), credentialType);
C credential = currentIdentity.getCredential(credentialType);
if (credential != null) {
return credential;
}
} while (nextIdentity());
return null;
}
@Override
public boolean verifyEvidence(final Evidence evidence) throws RealmUnavailableException {
return currentIdentity.verifyEvidence(evidence);
}
@Override
public boolean exists() throws RealmUnavailableException {
return currentIdentity.exists();
}
@Override
public AuthorizationIdentity getAuthorizationIdentity() throws RealmUnavailableException {
return currentIdentity.getAuthorizationIdentity();
}
@Override
public void dispose() {
currentIdentity.dispose();
}
}
}
| 9,863
| 38.614458
| 240
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/realm/PropertiesSecurityRealm.java
|
package org.infinispan.server.security.realm;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.Principal;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Properties;
import java.util.function.Consumer;
import org.infinispan.server.Server;
import org.wildfly.security.auth.SupportLevel;
import org.wildfly.security.auth.realm.CacheableSecurityRealm;
import org.wildfly.security.auth.server.ModifiableRealmIdentityIterator;
import org.wildfly.security.auth.server.ModifiableSecurityRealm;
import org.wildfly.security.auth.server.RealmIdentity;
import org.wildfly.security.auth.server.RealmUnavailableException;
import org.wildfly.security.credential.Credential;
import org.wildfly.security.evidence.Evidence;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class PropertiesSecurityRealm implements CacheableSecurityRealm, ModifiableSecurityRealm {
private final File usersFile;
private final File groupsFile;
private final boolean plainText;
private final String groupsAttribute;
private final String realmName;
EncryptedPropertiesSecurityRealm delegate;
public PropertiesSecurityRealm(File usersFile, File groupsFile, boolean plainText, String groupsAttribute, String realmName) {
this.usersFile = usersFile;
this.groupsFile = groupsFile;
this.plainText = plainText;
this.groupsAttribute = groupsAttribute;
this.realmName = realmName;
load();
}
private void load() {
delegate = EncryptedPropertiesSecurityRealm.builder()
.setPlainText(plainText)
.setGroupsAttribute(groupsAttribute)
.setDefaultRealm(realmName)
.build();
}
void reload() {
long loadTime = delegate.getLoadTime();
if (usersFile.lastModified() > loadTime || groupsFile.lastModified() > loadTime) {
try (InputStream usersInputStream = new FileInputStream(usersFile);
InputStream groupsInputStream = groupsFile != null ? new FileInputStream(groupsFile) : null) {
delegate.load(usersInputStream, groupsInputStream);
} catch (IOException e) {
throw Server.log.unableToLoadRealmPropertyFiles(e);
}
}
}
@Override
public RealmIdentity getRealmIdentity(Principal principal) throws RealmUnavailableException {
reload();
return delegate.getRealmIdentity(principal);
}
@Override
public RealmIdentity getRealmIdentity(Evidence evidence) throws RealmUnavailableException {
reload();
return delegate.getRealmIdentity(evidence);
}
@Override
public SupportLevel getCredentialAcquireSupport(Class<? extends Credential> credentialType, String algorithmName, AlgorithmParameterSpec parameterSpec) {
return delegate.getCredentialAcquireSupport(credentialType, algorithmName, parameterSpec);
}
@Override
public SupportLevel getEvidenceVerifySupport(Class<? extends Evidence> evidenceType, String algorithmName) {
return delegate.getEvidenceVerifySupport(evidenceType, algorithmName);
}
public boolean isEmpty() {
Properties p = new Properties();
try (InputStream is = new FileInputStream(usersFile)) {
p.load(is);
} catch (IOException e) {
// Ignore
}
return p.isEmpty();
}
@Override
public void registerIdentityChangeListener(Consumer<Principal> listener) {
delegate.registerIdentityChangeListener(listener);
}
@Override
public ModifiableRealmIdentityIterator getRealmIdentityIterator() {
reload();
return delegate.getRealmIdentityIterator();
}
}
| 3,715
| 34.056604
| 156
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/realm/EncryptedPropertiesSecurityRealm.java
|
package org.infinispan.server.security.realm;
import static org.infinispan.server.Server.log;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.security.Principal;
import java.security.Provider;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.InvalidKeySpecException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import org.infinispan.server.Server;
import org.infinispan.server.security.ElytronPasswordProviderSupplier;
import org.wildfly.common.Assert;
import org.wildfly.common.iteration.CodePointIterator;
import org.wildfly.security.auth.SupportLevel;
import org.wildfly.security.auth.principal.NamePrincipal;
import org.wildfly.security.auth.realm.CacheableSecurityRealm;
import org.wildfly.security.auth.server.ModifiableRealmIdentity;
import org.wildfly.security.auth.server.ModifiableRealmIdentityIterator;
import org.wildfly.security.auth.server.ModifiableSecurityRealm;
import org.wildfly.security.auth.server.RealmIdentity;
import org.wildfly.security.auth.server.RealmUnavailableException;
import org.wildfly.security.auth.server.SecurityRealm;
import org.wildfly.security.authz.Attributes;
import org.wildfly.security.authz.AuthorizationIdentity;
import org.wildfly.security.authz.MapAttributes;
import org.wildfly.security.credential.Credential;
import org.wildfly.security.credential.PasswordCredential;
import org.wildfly.security.evidence.Evidence;
import org.wildfly.security.evidence.PasswordGuessEvidence;
import org.wildfly.security.password.PasswordFactory;
import org.wildfly.security.password.spec.BasicPasswordSpecEncoding;
import org.wildfly.security.password.spec.ClearPasswordSpec;
import org.wildfly.security.password.spec.PasswordSpec;
/**
* A {@link SecurityRealm} implementation that uses property files with encrypted passwords
*
* @author Darran Lofthouse <darran.lofthouse@jboss.com>
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
*/
public class EncryptedPropertiesSecurityRealm implements CacheableSecurityRealm, ModifiableSecurityRealm {
private static final String COMMENT_PREFIX1 = "#";
private static final String COMMENT_PREFIX2 = "!";
private static final String REALM_COMMENT_PREFIX = "$REALM_NAME=";
private static final String COMMENT_SUFFIX = "$";
private static final String ALGORITHM_COMMENT_PREFIX = "$ALGORITHM=";
private final Supplier<Provider[]> providers;
private final String defaultRealm;
private final boolean plainText;
private final String groupsAttribute;
private final AtomicReference<LoadedState> loadedState = new AtomicReference<>();
private Set<Consumer<Principal>> listeners = new LinkedHashSet<>();
private EncryptedPropertiesSecurityRealm(Builder builder) {
plainText = builder.plainText;
groupsAttribute = builder.groupsAttribute;
providers = ElytronPasswordProviderSupplier.INSTANCE;
defaultRealm = builder.defaultRealm;
try {
load(null, null);
} catch (IOException e) {
Server.log.debugf(e, "Error while loading properties");
}
}
@Override
public RealmIdentity getRealmIdentity(final Principal principal) {
if (!(principal instanceof NamePrincipal)) {
log.tracef("PropertiesRealm: unsupported principal type: [%s]", principal);
return RealmIdentity.NON_EXISTENT;
}
final LoadedState loadedState = this.loadedState.get();
final AccountEntry accountEntry = loadedState.getAccounts().get(principal.getName());
if (accountEntry == null) {
log.tracef("PropertiesRealm: identity [%s] does not exist", principal);
return RealmIdentity.NON_EXISTENT;
}
return new RealmIdentity() {
@Override
public Principal getRealmIdentityPrincipal() {
return principal;
}
@Override
public SupportLevel getCredentialAcquireSupport(final Class<? extends Credential> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) {
for (Credential credential : accountEntry.getCredentials()) {
if (credential != null && credential.matches(credentialType, algorithmName, parameterSpec)) {
return SupportLevel.SUPPORTED;
}
}
return SupportLevel.UNSUPPORTED;
}
@Override
public SupportLevel getEvidenceVerifySupport(final Class<? extends Evidence> evidenceType, final String algorithmName) {
for (Credential credential : accountEntry.getCredentials()) {
if (credential != null && credential.canVerify(evidenceType, algorithmName)) {
return SupportLevel.SUPPORTED;
}
}
return SupportLevel.UNSUPPORTED;
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType) {
return getCredential(credentialType, null);
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName) {
return getCredential(credentialType, algorithmName, null);
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) {
for (Credential credential : accountEntry.getCredentials()) {
if (credential != null && credential.matches(credentialType, algorithmName, parameterSpec)) {
return credentialType.cast(credential.clone());
}
}
return null;
}
@Override
public boolean verifyEvidence(final Evidence evidence) {
for (Credential credential : accountEntry.getCredentials()) {
if (credential != null && credential.canVerify(evidence)) {
return credential.verify(evidence);
}
}
log.tracef("Unable to verify evidence for identity [%s]", principal);
return false;
}
@Override
public boolean exists() {
return true;
}
@Override
public AuthorizationIdentity getAuthorizationIdentity() {
return AuthorizationIdentity.basicIdentity(new MapAttributes(Collections.singletonMap(groupsAttribute, accountEntry.getGroups())));
}
};
}
private PasswordFactory getPasswordFactory(final String algorithm) {
try {
return PasswordFactory.getInstance(algorithm, providers);
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException(e);
}
}
@Override
public SupportLevel getCredentialAcquireSupport(final Class<? extends Credential> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) {
Assert.checkNotNullParam("credentialType", credentialType);
return PasswordCredential.class.isAssignableFrom(credentialType) ? SupportLevel.POSSIBLY_SUPPORTED : SupportLevel.UNSUPPORTED;
}
@Override
public SupportLevel getEvidenceVerifySupport(final Class<? extends Evidence> evidenceType, final String algorithmName) {
return PasswordGuessEvidence.class.isAssignableFrom(evidenceType) ? SupportLevel.SUPPORTED : SupportLevel.UNSUPPORTED;
}
/**
* Loads this properties security realm from the given user and groups input streams.
*
* @param usersStream the input stream from which the realm users are loaded
* @param groupsStream the input stream from which the roles of realm users are loaded
* @throws IOException if there is problem while reading the input streams or invalid content is loaded from streams
*/
public void load(InputStream usersStream, InputStream groupsStream) throws IOException {
Map<String, AccountEntry> accounts = new HashMap<>();
Properties groups = new Properties();
if (groupsStream != null) {
try (InputStreamReader is = new InputStreamReader(groupsStream, StandardCharsets.UTF_8);) {
groups.load(is);
}
}
long loadTime = 0;
String realmName = null;
String algorithm = "clear";
if (usersStream != null) {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(usersStream, StandardCharsets.UTF_8))) {
String currentLine;
while ((currentLine = reader.readLine()) != null) {
final String trimmed = currentLine.trim();
if (trimmed.startsWith(COMMENT_PREFIX1) && trimmed.contains(REALM_COMMENT_PREFIX)) {
// this is the line that contains the realm name.
int start = trimmed.indexOf(REALM_COMMENT_PREFIX) + REALM_COMMENT_PREFIX.length();
int end = trimmed.indexOf(COMMENT_SUFFIX, start);
if (end > -1) {
realmName = trimmed.substring(start, end);
}
} else if (trimmed.startsWith(COMMENT_PREFIX1) && trimmed.contains(ALGORITHM_COMMENT_PREFIX)) {
// this is the line that contains the algorithm name.
int start = trimmed.indexOf(ALGORITHM_COMMENT_PREFIX) + ALGORITHM_COMMENT_PREFIX.length();
int end = trimmed.indexOf(COMMENT_SUFFIX, start);
if (end > -1) {
algorithm = trimmed.substring(start, end);
}
} else {
if (!(trimmed.startsWith(COMMENT_PREFIX1) || trimmed.startsWith(COMMENT_PREFIX2))) {
String username = null;
StringBuilder builder = new StringBuilder();
CodePointIterator it = CodePointIterator.ofString(trimmed);
while (it.hasNext()) {
int cp = it.next();
if (cp == '\\' && it.hasNext()) { // escape
//might be regular escape of regex like characters \\t \\! or unicode \\uxxxx
int marker = it.next();
if (marker != 'u') {
builder.appendCodePoint(marker);
} else {
StringBuilder hex = new StringBuilder();
try {
hex.appendCodePoint(it.next());
hex.appendCodePoint(it.next());
hex.appendCodePoint(it.next());
hex.appendCodePoint(it.next());
builder.appendCodePoint((char) Integer.parseInt(hex.toString(), 16));
} catch (NoSuchElementException nsee) {
throw Server.log.invalidUnicodeSequence(hex.toString(), nsee);
}
}
} else if (username == null && (cp == '=' || cp == ':')) { // username-password delimiter
username = builder.toString().trim();
builder = new StringBuilder();
} else {
builder.appendCodePoint(cp);
}
}
if (username != null) { // end of line and delimiter was read
List<Credential> credentials = new ArrayList<>();
switch (algorithm) {
case "encrypted":
String[] passwords = builder.toString().trim().split(";");
for (String password : passwords) {
int colon = password.indexOf(':');
byte[] passwordBytes = CodePointIterator.ofChars(password.substring(colon + 1).toCharArray()).base64Decode().drain();
PasswordFactory factory = getPasswordFactory(password.substring(0, colon));
PasswordSpec passwordSpec = BasicPasswordSpecEncoding.decode(passwordBytes);
try {
credentials.add(new PasswordCredential(factory.generatePassword(passwordSpec)));
} catch (InvalidKeySpecException e) {
throw new IOException(e);
}
}
break;
case "clear":
PasswordFactory factory = getPasswordFactory("clear");
try {
credentials.add(new PasswordCredential(factory.generatePassword(new ClearPasswordSpec(builder.toString().trim().toCharArray()))));
} catch (InvalidKeySpecException e) {
throw new IOException(e);
}
break;
}
accounts.put(username, new AccountEntry(username, credentials, groups.getProperty(username)));
// Notify any caching layer that the principal has been reloaded
for (Consumer<Principal> listener : listeners) {
listener.accept(new NamePrincipal(username));
}
}
}
}
}
}
if (realmName == null) {
if (defaultRealm != null || plainText) {
realmName = defaultRealm;
} else {
throw log.noRealmFoundInProperties();
}
}
loadTime = System.currentTimeMillis();
}
// users, which are in groups file only
for (String userName : groups.stringPropertyNames()) {
if (!accounts.containsKey(userName)) {
accounts.put(userName, new AccountEntry(userName, null, groups.getProperty(userName)));
}
}
loadedState.set(new LoadedState(accounts, realmName, loadTime));
}
/**
* Get the time when the realm was last loaded.
*
* @return the time when the realm was last loaded (number of milliseconds since the standard base time)
*/
public long getLoadTime() {
return loadedState.get().getLoadTime();
}
/**
* Obtain a new {@link Builder} capable of building a {@link EncryptedPropertiesSecurityRealm}.
*
* @return a new {@link Builder} capable of building a {@link EncryptedPropertiesSecurityRealm}.
*/
public static Builder builder() {
return new Builder();
}
@Override
public void registerIdentityChangeListener(Consumer<Principal> listener) {
listeners.add(listener);
}
@Override
public ModifiableRealmIdentityIterator getRealmIdentityIterator() {
final LoadedState loadedState = this.loadedState.get();
Iterator<AccountEntry> accountIterator = loadedState.getAccounts().values().stream().iterator();
return new ModifiableRealmIdentityIterator() {
@Override
public boolean hasNext() {
return accountIterator.hasNext();
}
@Override
public ModifiableRealmIdentity next() {
AccountEntry entry = accountIterator.next();
return new ModifiableRealmIdentity() {
@Override
public void delete() {
throw new UnsupportedOperationException();
}
@Override
public void create() {
throw new UnsupportedOperationException();
}
@Override
public void setCredentials(Collection<? extends Credential> credentials) {
throw new UnsupportedOperationException();
}
@Override
public void setAttributes(Attributes attributes) {
throw new UnsupportedOperationException();
}
@Override
public Principal getRealmIdentityPrincipal() {
return new NamePrincipal(entry.name);
}
@Override
public SupportLevel getCredentialAcquireSupport(Class<? extends Credential> credentialType, String algorithmName, AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
throw new UnsupportedOperationException();
}
@Override
public <C extends Credential> C getCredential(Class<C> credentialType) {
throw new UnsupportedOperationException();
}
@Override
public SupportLevel getEvidenceVerifySupport(Class<? extends Evidence> evidenceType, String algorithmName) {
throw new UnsupportedOperationException();
}
@Override
public boolean verifyEvidence(Evidence evidence) {
throw new UnsupportedOperationException();
}
@Override
public boolean exists() {
return true;
}
};
}
};
}
/**
* A builder for properties security realms.
*/
public static class Builder {
private String defaultRealm = null;
private boolean plainText;
private String groupsAttribute = "groups";
Builder() {
}
/**
* Where this realm returns an {@link AuthorizationIdentity} set the key on the Attributes that will be used to
* hold the group membership information.
*
* @param groupsAttribute the key on the Attributes that will be used to hold the group membership information.
* @return this {@link Builder}
*/
public Builder setGroupsAttribute(final String groupsAttribute) {
this.groupsAttribute = groupsAttribute;
return this;
}
/**
* Set the default realm name to use if no realm name is discovered in the properties file.
*
* @param defaultRealm the default realm name if one is not discovered in the properties file.
* @return this {@link Builder}
*/
public Builder setDefaultRealm(String defaultRealm) {
this.defaultRealm = defaultRealm;
return this;
}
/**
* Set format of users property file - if the passwords are stored in plain text. Otherwise is HEX( MD5( username
* ":" realm ":" password ) ) expected.
*
* @param plainText if the passwords are stored in plain text.
* @return this {@link Builder}
*/
public Builder setPlainText(boolean plainText) {
this.plainText = plainText;
return this;
}
/**
* Builds the {@link EncryptedPropertiesSecurityRealm}.
*
* @return built {@link EncryptedPropertiesSecurityRealm}
*/
public EncryptedPropertiesSecurityRealm build() {
return new EncryptedPropertiesSecurityRealm(this);
}
}
private static class LoadedState {
private final Map<String, AccountEntry> accounts;
private final String realmName;
private final long loadTime;
private LoadedState(Map<String, AccountEntry> accounts, String realmName, long loadTime) {
this.accounts = accounts;
this.realmName = realmName;
this.loadTime = loadTime;
}
public Map<String, AccountEntry> getAccounts() {
return accounts;
}
public String getRealmName() {
return realmName;
}
public long getLoadTime() {
return loadTime;
}
}
private static class AccountEntry {
private final String name;
private final List<Credential> credentials;
private final Set<String> groups;
private AccountEntry(String name, List<Credential> credentials, String groups) {
this.name = name;
this.credentials = credentials;
this.groups = convertGroups(groups);
}
private Set<String> convertGroups(String groups) {
if (groups == null) {
return Collections.emptySet();
}
return Arrays.stream(groups.split(","))
.map(String::trim)
.filter(s -> !s.isEmpty())
.collect(Collectors.collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet));
}
public String getName() {
return name;
}
public List<Credential> getCredentials() {
return credentials;
}
public Set<String> getGroups() {
return groups;
}
}
}
| 21,456
| 38.735185
| 201
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/realm/KerberosSecurityRealm.java
|
package org.infinispan.server.security.realm;
import java.security.spec.AlgorithmParameterSpec;
import org.wildfly.security.SecurityFactory;
import org.wildfly.security.auth.SupportLevel;
import org.wildfly.security.auth.server.RealmUnavailableException;
import org.wildfly.security.auth.server.SecurityRealm;
import org.wildfly.security.credential.Credential;
import org.wildfly.security.credential.GSSKerberosCredential;
import org.wildfly.security.evidence.Evidence;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class KerberosSecurityRealm implements SecurityRealm {
private final SecurityFactory<GSSKerberosCredential> kerberosCredentialSecurityFactory;
public KerberosSecurityRealm(SecurityFactory<GSSKerberosCredential> kerberosCredentialSecurityFactory) {
this.kerberosCredentialSecurityFactory = kerberosCredentialSecurityFactory;
}
@Override
public SupportLevel getCredentialAcquireSupport(Class<? extends Credential> credentialType, String algorithmName, AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
return null;
}
@Override
public SupportLevel getEvidenceVerifySupport(Class<? extends Evidence> evidenceType, String algorithmName) throws RealmUnavailableException {
return null;
}
}
| 1,317
| 37.764706
| 189
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/realm/CachingModifiableSecurityRealm.java
|
package org.infinispan.server.security.realm;
import java.security.Principal;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Collection;
import java.util.function.Function;
import org.wildfly.common.function.ExceptionConsumer;
import org.wildfly.security.auth.SupportLevel;
import org.wildfly.security.auth.realm.CacheableSecurityRealm;
import org.wildfly.security.auth.server.ModifiableRealmIdentity;
import org.wildfly.security.auth.server.ModifiableRealmIdentityIterator;
import org.wildfly.security.auth.server.ModifiableSecurityRealm;
import org.wildfly.security.auth.server.RealmIdentity;
import org.wildfly.security.auth.server.RealmUnavailableException;
import org.wildfly.security.auth.server.SecurityRealm;
import org.wildfly.security.authz.Attributes;
import org.wildfly.security.authz.AuthorizationIdentity;
import org.wildfly.security.cache.RealmIdentityCache;
import org.wildfly.security.credential.Credential;
import org.wildfly.security.evidence.Evidence;
/**
* <p>A wrapper class that provides caching capabilities for a {@link ModifiableSecurityRealm} and its identities.
*
* @author <a href="mailto:psilva@redhat.com">Pedro Igor</a>
*/
public class CachingModifiableSecurityRealm extends CachingSecurityRealm implements ModifiableSecurityRealm {
/**
* Creates a new instance.
*
* @param realm the {@link SecurityRealm} whose {@link RealmIdentity} should be cached..
* @param cache the {@link RealmIdentityCache} instance
*/
public CachingModifiableSecurityRealm(CacheableSecurityRealm realm, RealmIdentityCache cache) {
super(realm, cache);
}
@Override
public ModifiableRealmIdentity getRealmIdentityForUpdate(Principal principal) throws RealmUnavailableException {
return wrap(getModifiableSecurityRealm().getRealmIdentityForUpdate(principal));
}
@Override
public ModifiableRealmIdentityIterator getRealmIdentityIterator() throws RealmUnavailableException {
ModifiableRealmIdentityIterator iterator = getModifiableSecurityRealm().getRealmIdentityIterator();
return new ModifiableRealmIdentityIterator() {
@Override
public boolean hasNext() {
return iterator.hasNext();
}
@Override
public ModifiableRealmIdentity next() {
return wrap(iterator.next());
}
};
}
private ModifiableRealmIdentity wrap(final ModifiableRealmIdentity modifiable) {
return new ModifiableRealmIdentity() {
@Override
public void delete() throws RealmUnavailableException {
executeAndInvalidate(modifiable -> {
modifiable.delete();
});
}
@Override
public void create() throws RealmUnavailableException {
modifiable.create();
}
@Override
public void setCredentials(Collection<? extends Credential> credentials) throws RealmUnavailableException {
executeAndInvalidate(modifiable -> {
modifiable.setCredentials(credentials);
});
}
@Override
public void setAttributes(Attributes attributes) throws RealmUnavailableException {
executeAndInvalidate(modifiable -> {
modifiable.setAttributes(attributes);
});
}
@Override
public SupportLevel getCredentialAcquireSupport(Class<? extends Credential> credentialType, String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
return modifiable.getCredentialAcquireSupport(credentialType, algorithmName, parameterSpec);
}
@Override
public <C extends Credential> C getCredential(Class<C> credentialType) throws RealmUnavailableException {
return modifiable.getCredential(credentialType);
}
@Override
public SupportLevel getEvidenceVerifySupport(Class<? extends Evidence> evidenceType, String algorithmName) throws RealmUnavailableException {
return modifiable.getEvidenceVerifySupport(evidenceType, algorithmName);
}
@Override
public boolean verifyEvidence(Evidence evidence) throws RealmUnavailableException {
return modifiable.verifyEvidence(evidence);
}
@Override
public boolean exists() throws RealmUnavailableException {
return modifiable.exists();
}
@Override
public void updateCredential(Credential credential) throws RealmUnavailableException {
executeAndInvalidate(modifiable -> {
modifiable.updateCredential(credential);
});
}
@Override
public Principal getRealmIdentityPrincipal() {
return modifiable.getRealmIdentityPrincipal();
}
@Override
public <C extends Credential> C getCredential(Class<C> credentialType, String algorithmName) throws RealmUnavailableException {
return modifiable.getCredential(credentialType, algorithmName);
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
return modifiable.getCredential(credentialType, algorithmName, parameterSpec);
}
@Override
public <C extends Credential, R> R applyToCredential(Class<C> credentialType, Function<C, R> function) throws RealmUnavailableException {
return modifiable.applyToCredential(credentialType, function);
}
@Override
public <C extends Credential, R> R applyToCredential(Class<C> credentialType, String algorithmName, Function<C, R> function) throws RealmUnavailableException {
return modifiable.applyToCredential(credentialType, algorithmName, function);
}
@Override
public <C extends Credential, R> R applyToCredential(final Class<C> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec, final Function<C, R> function) throws RealmUnavailableException {
return modifiable.applyToCredential(credentialType, algorithmName, parameterSpec, function);
}
@Override
public void dispose() {
modifiable.dispose();
}
@Override
public AuthorizationIdentity getAuthorizationIdentity() throws RealmUnavailableException {
return modifiable.getAuthorizationIdentity();
}
@Override
public Attributes getAttributes() throws RealmUnavailableException {
return modifiable.getAttributes();
}
private void executeAndInvalidate(ExceptionConsumer<ModifiableRealmIdentity, RealmUnavailableException> operation) throws RealmUnavailableException {
try {
operation.accept(modifiable);
} catch (RealmUnavailableException rue) {
throw rue;
} finally {
removeFromCache(modifiable.getRealmIdentityPrincipal());
}
}
};
}
private ModifiableSecurityRealm getModifiableSecurityRealm() {
return (ModifiableSecurityRealm) getCacheableRealm();
}
}
| 7,338
| 39.324176
| 230
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/realm/CachingSecurityRealm.java
|
package org.infinispan.server.security.realm;
import static org.infinispan.server.Server.log;
import static org.wildfly.common.Assert.checkNotNullParam;
import java.security.Principal;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Arrays;
import org.infinispan.server.security.ElytronPasswordProviderSupplier;
import org.wildfly.security.auth.SupportLevel;
import org.wildfly.security.auth.realm.CacheableSecurityRealm;
import org.wildfly.security.auth.server.IdentityCredentials;
import org.wildfly.security.auth.server.RealmIdentity;
import org.wildfly.security.auth.server.RealmUnavailableException;
import org.wildfly.security.auth.server.SecurityRealm;
import org.wildfly.security.auth.server.event.RealmEvent;
import org.wildfly.security.authz.Attributes;
import org.wildfly.security.authz.AuthorizationIdentity;
import org.wildfly.security.cache.RealmIdentityCache;
import org.wildfly.security.credential.Credential;
import org.wildfly.security.credential.PasswordCredential;
import org.wildfly.security.evidence.Evidence;
import org.wildfly.security.evidence.PasswordGuessEvidence;
import org.wildfly.security.password.Password;
import org.wildfly.security.password.interfaces.ClearPassword;
/**
* <p>A wrapper class that provides caching capabilities for a {@link SecurityRealm} and its identities.
*
* @author <a href="mailto:psilva@redhat.com">Pedro Igor</a>
*/
public class CachingSecurityRealm implements SecurityRealm {
private final CacheableSecurityRealm realm;
private final RealmIdentityCache cache;
/**
* Creates a new instance.
*
* @param realm the {@link SecurityRealm} whose {@link RealmIdentity} should be cached.
* @param cache the {@link RealmIdentityCache} instance
*/
public CachingSecurityRealm(CacheableSecurityRealm realm, RealmIdentityCache cache) {
this.realm = checkNotNullParam("realm", realm);
this.cache = checkNotNullParam("cache", cache);
CacheableSecurityRealm cacheable = realm;
cacheable.registerIdentityChangeListener(this::removeFromCache);
}
@Override
public RealmIdentity getRealmIdentity(Principal principal) throws RealmUnavailableException {
RealmIdentity cached = cache.get(principal);
if (cached != null) {
if(log.isTraceEnabled()) {
log.tracef("Returning cached RealmIdentity for '%s'", principal);
}
return cached;
}
RealmIdentity realmIdentity = getCacheableRealm().getRealmIdentity(principal);
if (!realmIdentity.exists()) {
if(log.isTraceEnabled()) {
log.tracef("RealmIdentity for '%s' does not exist, skipping cache.'", principal);
}
return realmIdentity;
}
RealmIdentity cachedIdentity = new RealmIdentity() {
final RealmIdentity identity = realmIdentity;
AuthorizationIdentity authorizationIdentity = null;
Attributes attributes = null;
IdentityCredentials credentials = IdentityCredentials.NONE;
int verifiedEvidenceHash;
@Override
public Principal getRealmIdentityPrincipal() {
return identity.getRealmIdentityPrincipal();
}
@Override
public SupportLevel getCredentialAcquireSupport(Class<? extends Credential> credentialType, String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
if (credentials.contains(credentialType, algorithmName, parameterSpec)) {
if (log.isTraceEnabled()) {
log.tracef("getCredentialAcquireSupport credentialType='%s' with algorithmName='%' known for pincipal='%s'", credentialType.getName(), algorithmName, principal.getName());
}
return credentials.getCredentialAcquireSupport(credentialType, algorithmName, parameterSpec);
}
Credential credential = identity.getCredential(credentialType, algorithmName, parameterSpec);
if (credential != null) {
if (log.isTraceEnabled()) {
log.tracef("getCredentialAcquireSupport Credential for credentialType='%s' with algorithmName='%' obtained from identity - caching for principal='%s'",
credentialType.getName(), algorithmName, principal.getName());
}
credentials = credentials.withCredential(credential);
}
return credentials.getCredentialAcquireSupport(credentialType, algorithmName, parameterSpec);
}
@Override
public <C extends Credential> C getCredential(Class<C> credentialType) throws RealmUnavailableException {
if (credentials.contains(credentialType)) {
if (log.isTraceEnabled()) {
log.tracef("getCredential credentialType='%s' cached, returning cached credential for principal='%s'", credentialType.getName(), principal.getName());
}
return credentials.getCredential(credentialType);
}
Credential credential = identity.getCredential(credentialType);
if (credential != null) {
if (log.isTraceEnabled()) {
log.tracef("getCredential credentialType='%s' obtained from identity - caching for principal='%s'", credentialType.getName(), principal.getName());
}
credentials = credentials.withCredential(credential);
}
return credentials.getCredential(credentialType);
}
@Override
public <C extends Credential> C getCredential(Class<C> credentialType, String algorithmName) throws RealmUnavailableException {
if (credentials.contains(credentialType, algorithmName)) {
if (log.isTraceEnabled()) {
log.tracef("getCredential credentialType='%s' with algorithmName='%' cached, returning cached credential for principal='%s'", credentialType.getName(), algorithmName, principal.getName());
}
return credentials.getCredential(credentialType, algorithmName);
}
Credential credential = identity.getCredential(credentialType, algorithmName);
if (credential != null) {
if (log.isTraceEnabled()) {
log.tracef("getCredential credentialType='%s' with algorithmName='%' obtained from identity - caching.", credentialType.getName(), algorithmName);
}
credentials = credentials.withCredential(credential);
}
return credentials.getCredential(credentialType, algorithmName);
}
@Override
public <C extends Credential> C getCredential(final Class<C> credentialType, final String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
if (credentials.contains(credentialType, algorithmName, parameterSpec)) {
if (log.isTraceEnabled()) {
log.tracef("getCredential credentialType='%s' with algorithmName='%s' cached, returning cached credential for principal='%s'", credentialType.getName(), algorithmName, principal.getName());
}
return credentials.getCredential(credentialType, algorithmName, parameterSpec);
}
Credential credential = identity.getCredential(credentialType, algorithmName, parameterSpec);
if (credential != null) {
if (log.isTraceEnabled()) {
log.tracef("getCredential credentialType='%s' with algorithmName='%s' obtained from identity - caching for principal='%s'", credentialType.getName(), algorithmName, principal.getName());
}
credentials = credentials.withCredential(credential);
}
return credentials.getCredential(credentialType, algorithmName, parameterSpec);
}
@Override
public void updateCredential(Credential credential) throws RealmUnavailableException {
if(log.isTraceEnabled()) {
log.tracef("updateCredential For principal='%s'", principal);
}
try {
identity.updateCredential(credential);
} finally {
removeFromCache(identity.getRealmIdentityPrincipal());
}
}
@Override
public SupportLevel getEvidenceVerifySupport(Class<? extends Evidence> evidenceType, String algorithmName) throws RealmUnavailableException {
if (PasswordGuessEvidence.class.isAssignableFrom(evidenceType)) {
if (credentials.canVerify(evidenceType, algorithmName)) {
if (log.isTraceEnabled()) {
log.tracef("getEvidenceVerifySupport evidenceType='%s' with algorithmName='%' can verify from cache for principal='%s'", evidenceType.getName(), algorithmName, principal.getName());
}
return SupportLevel.SUPPORTED;
}
Credential credential = identity.getCredential(PasswordCredential.class);
if (credential != null) {
if (log.isTraceEnabled()) {
log.tracef("getEvidenceVerifySupport evidenceType='%s' with algorithmName='%' credential obtained from identity and cached for principal='%s'",
evidenceType.getName(), algorithmName, principal.getName());
}
credentials = credentials.withCredential(credential);
if (credential.canVerify(evidenceType, algorithmName)) {
return SupportLevel.SUPPORTED;
}
}
}
if (log.isTraceEnabled()) {
log.tracef("getEvidenceVerifySupport evidenceType='%s' with algorithmName='%' falling back to direct support of identity for principal='%s'",
evidenceType.getName(), algorithmName, principal.getName());
}
return identity.getEvidenceVerifySupport(evidenceType, algorithmName);
}
@Override
public boolean verifyEvidence(Evidence evidence) throws RealmUnavailableException {
if (evidence instanceof PasswordGuessEvidence) {
char[] guess = ((PasswordGuessEvidence) evidence).getGuess();
int evidenceHash = Arrays.hashCode(guess);
if (evidenceHash == verifiedEvidenceHash) {
return true;
}
if (credentials.canVerify(evidence)) {
if(log.isTraceEnabled()) {
log.tracef("verifyEvidence For principal='%s' using cached credential", principal);
}
return credentials.verify(evidence);
}
Credential credential = identity.getCredential(PasswordCredential.class);
if (credential != null) {
if(log.isTraceEnabled()) {
log.tracef("verifyEvidence Credential obtained from identity and cached for principal='%s'", principal);
}
credentials = credentials.withCredential(credential);
if (credential.canVerify(evidence)) {
boolean res = credential.verify(ElytronPasswordProviderSupplier.INSTANCE, evidence);
if (res) {
verifiedEvidenceHash = evidenceHash;
}
return res;
}
}
Password password = ClearPassword.createRaw(ClearPassword.ALGORITHM_CLEAR, guess);
if(log.isTraceEnabled()) {
log.tracef("verifyEvidence Falling back to direct support of identity for principal='%s'", principal);
}
if (identity.verifyEvidence(evidence)) {
credentials = credentials.withCredential(new PasswordCredential(password));
return true;
}
return false;
}
return identity.verifyEvidence(evidence);
}
@Override
public boolean exists() throws RealmUnavailableException {
return true; // non-existing identities will not be wrapped
}
@Override
public AuthorizationIdentity getAuthorizationIdentity() throws RealmUnavailableException {
if (authorizationIdentity == null) {
if(log.isTraceEnabled()) {
log.tracef("getAuthorizationIdentity Caching AuthorizationIdentity for principal='%s'", principal);
}
authorizationIdentity = identity.getAuthorizationIdentity();
}
return authorizationIdentity;
}
@Override
public Attributes getAttributes() throws RealmUnavailableException {
if (attributes == null) {
if(log.isTraceEnabled()) {
log.tracef("getAttributes Caching Attributes for principal='%s'", principal);
}
attributes = identity.getAttributes();
}
return attributes;
}
@Override
public void dispose() {
identity.dispose();
}
};
if(log.isTraceEnabled()) {
log.tracef("Created wrapper RealmIdentity for '%s' and placing in cache.", principal);
}
cache.put(principal, cachedIdentity);
return cachedIdentity;
}
@Override
public SupportLevel getCredentialAcquireSupport(Class<? extends Credential> credentialType, String algorithmName, final AlgorithmParameterSpec parameterSpec) throws RealmUnavailableException {
return getCacheableRealm().getCredentialAcquireSupport(credentialType, algorithmName, parameterSpec);
}
@Override
public SupportLevel getEvidenceVerifySupport(Class<? extends Evidence> evidenceType, String algorithmName) throws RealmUnavailableException {
return getCacheableRealm().getEvidenceVerifySupport(evidenceType, algorithmName);
}
@Override
public void handleRealmEvent(RealmEvent event) {
getCacheableRealm().handleRealmEvent(event);
}
/**
* Removes a {@link RealmIdentity} referenced by the specified {@link Principal} from the cache.
*
* @param principal the {@link Principal} that references a previously cached realm identity
*/
public void removeFromCache(Principal principal) {
cache.remove(principal);
}
/**
* Removes all cached identities from the cache.
*/
public void removeAllFromCache() {
cache.clear();
}
/**
* Gets wrapped backing realm.
*
* @return the wrapped backing realm
*/
protected CacheableSecurityRealm getCacheableRealm() {
return realm;
}
}
| 14,829
| 45.489028
| 207
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/http/localuser/LocalUserMechanismFactory.java
|
package org.infinispan.server.security.http.localuser;
import static org.infinispan.server.security.http.localuser.LocalUserAuthenticationMechanism.SILENT;
import static org.wildfly.common.Assert.checkNotNullParam;
import java.security.Provider;
import java.util.Map;
import javax.security.auth.callback.CallbackHandler;
import org.kohsuke.MetaInfServices;
import org.wildfly.security.http.HttpAuthenticationException;
import org.wildfly.security.http.HttpServerAuthenticationMechanism;
import org.wildfly.security.http.HttpServerAuthenticationMechanismFactory;
/**
* A {@link HttpServerAuthenticationMechanismFactory} implementation for the LOCALUSER HTTP authentication mechanism.
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
*/
@MetaInfServices(value = HttpServerAuthenticationMechanismFactory.class)
public class LocalUserMechanismFactory implements HttpServerAuthenticationMechanismFactory {
public LocalUserMechanismFactory() {
}
public LocalUserMechanismFactory(final Provider provider) {
}
@Override
public String[] getMechanismNames(Map<String, ?> properties) {
return new String[]{ LocalUserAuthenticationMechanism.LOCALUSER_NAME };
}
@Override
public HttpServerAuthenticationMechanism createAuthenticationMechanism(String mechanismName,
Map<String, ?> properties, CallbackHandler callbackHandler) throws HttpAuthenticationException {
checkNotNullParam("mechanismName", mechanismName);
checkNotNullParam("properties", properties);
checkNotNullParam("callbackHandler", callbackHandler);
if (LocalUserAuthenticationMechanism.LOCALUSER_NAME.equals(mechanismName)) {
return new LocalUserAuthenticationMechanism(callbackHandler,
Boolean.parseBoolean((String) properties.get(SILENT)));
}
return null;
}
}
| 1,894
| 35.442308
| 117
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/http/localuser/LocalUserAuthenticationMechanism.java
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015 Red Hat, Inc., and individual contributors
* as indicated by the @author tags.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.infinispan.server.security.http.localuser;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.wildfly.common.Assert.checkNotNullParam;
import static org.wildfly.security.http.HttpConstants.AUTHORIZATION;
import static org.wildfly.security.http.HttpConstants.UNAUTHORIZED;
import static org.wildfly.security.http.HttpConstants.WWW_AUTHENTICATE;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.SecureRandom;
import java.util.List;
import java.util.Random;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.UnsupportedCallbackException;
import org.wildfly.common.iteration.ByteIterator;
import org.wildfly.common.iteration.CodePointIterator;
import org.wildfly.security.http.HttpAuthenticationException;
import org.wildfly.security.http.HttpServerRequest;
import org.wildfly.security.http.HttpServerResponse;
import org.wildfly.security.mechanism.http.UsernamePasswordAuthenticationMechanism;
/**
* Implementation of the HTTP Local authentication mechanism
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
*/
final class LocalUserAuthenticationMechanism extends UsernamePasswordAuthenticationMechanism {
public static final String LOCALUSER_NAME = "LOCALUSER";
static final String SILENT = "silent";
public static final String LOCAL_USER_USE_SECURE_RANDOM = "wildfly.http.local-user.use-secure-random";
public static final String LOCAL_USER_CHALLENGE_PATH = "wildfly.http.local-user.challenge-path";
public static final String DEFAULT_USER = "wildfly.http.local-user.default-user";
private static final String CHALLENGE_PREFIX = "Localuser ";
private static final int PREFIX_LENGTH = CHALLENGE_PREFIX.length();
private static final byte UTF8NUL = 0x00;
private final boolean useSecureRandom;
/**
* If silent is true then this mechanism will only take effect if there is an Authorization header.
* <p>
* This allows you to combine basic auth with form auth, so human users will use form based auth, but allows
* programmatic clients to login using basic auth.
*/
private final boolean silent;
private final File basePath;
/**
* Construct a new instance of {@code BasicAuthenticationMechanism}.
*
* @param callbackHandler the {@link CallbackHandler} to use to verify the supplied credentials and to notify to
* establish the current identity.
*/
LocalUserAuthenticationMechanism(final CallbackHandler callbackHandler, final boolean silent) {
super(checkNotNullParam("callbackHandler", callbackHandler));
this.silent = silent;
this.useSecureRandom = true;
this.basePath = new File(System.getProperty("java.io.tmpdir"));
}
/**
* @see org.wildfly.security.http.HttpServerAuthenticationMechanism#getMechanismName()
*/
@Override
public String getMechanismName() {
return LOCALUSER_NAME;
}
/**
* @throws HttpAuthenticationException
* @see org.wildfly.security.http.HttpServerAuthenticationMechanism#evaluateRequest(HttpServerRequest)
*/
@Override
public void evaluateRequest(final HttpServerRequest request) throws HttpAuthenticationException {
List<String> authorizationValues = request.getRequestHeaderValues(AUTHORIZATION);
if (authorizationValues != null) {
for (String current : authorizationValues) {
if (current.startsWith(CHALLENGE_PREFIX)) {
byte[] decodedValue = ByteIterator.ofBytes(current.substring(PREFIX_LENGTH).getBytes(UTF_8)).asUtf8String().base64Decode().drain();
if (decodedValue.length == 0) {
// Initial response, create the file
final Random random = getRandom();
File challengeFile;
try {
challengeFile = File.createTempFile("local", ".challenge", basePath);
} catch (IOException e) {
throw new RuntimeException(e);
}
final FileOutputStream fos;
try {
fos = new FileOutputStream(challengeFile);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
boolean ok = false;
final byte[] bytes;
try {
bytes = new byte[8];
random.nextBytes(bytes);
try {
fos.write(bytes);
fos.close();
ok = true;
} catch (IOException e) {
throw new RuntimeException(e);
}
} finally {
if (!ok) {
deleteChallenge(null);
}
try {
fos.close();
} catch (Throwable ignored) {
}
}
//challengeBytes = bytes;
final String path = challengeFile.getAbsolutePath();
final byte[] response = CodePointIterator.ofString(path).asUtf8(true).drain();
} else {
try {
request.authenticationComplete();
if (true) {
succeed();
request.authenticationComplete();
return;
} else {
fail();
request.authenticationFailed("auth failed", response -> prepareResponse(request, response));
return;
}
} catch (IOException | UnsupportedCallbackException e) {
throw new HttpAuthenticationException(e);
}
}
}
}
}
}
private void prepareResponse(final HttpServerRequest request, HttpServerResponse response) {
if (silent) {
//if silent we only send a challenge if the request contained auth headers
//otherwise we assume another method will send the challenge
String authHeader = request.getFirstRequestHeaderValue(AUTHORIZATION);
if (authHeader == null) {
return; //CHALLENGE NOT SENT
}
}
StringBuilder sb = new StringBuilder(CHALLENGE_PREFIX);
response.addResponseHeader(WWW_AUTHENTICATE, sb.toString());
response.setStatusCode(UNAUTHORIZED);
}
private void deleteChallenge(File challengeFile) {
if (challengeFile != null) {
challengeFile.delete();
challengeFile = null;
}
}
private Random getRandom() {
if (useSecureRandom) {
return new SecureRandom();
} else {
return new Random();
}
}
}
| 7,716
| 38.372449
| 146
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/security/http/localuser/WildFlyElytronHttpLocalUserProvider.java
|
package org.infinispan.server.security.http.localuser;
import java.security.Provider;
import org.kohsuke.MetaInfServices;
import org.wildfly.security.WildFlyElytronBaseProvider;
/**
* Provider for the HTTP Local authentication mechanism.
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
*/
@MetaInfServices(Provider.class)
public final class WildFlyElytronHttpLocalUserProvider extends WildFlyElytronBaseProvider {
private static WildFlyElytronHttpLocalUserProvider INSTANCE = new WildFlyElytronHttpLocalUserProvider();
/**
* Construct a new instance.
*/
public WildFlyElytronHttpLocalUserProvider() {
super("WildFlyElytronHttpLocalUserProvider", "1.0", "WildFly Elytron HTTP LOCALUSER Provider");
putService(new ProviderService(this, HTTP_SERVER_FACTORY_TYPE, "LOCALUSER", "org.infinispan.server.security.http.localuser.LocalUserMechanismFactory", emptyList, emptyMap, true, true));
}
/**
* Get the HTTP BASIC authentication mechanism provider instance.
*
* @return the HTTP BASIC authentication mechanism provider instance
*/
public static WildFlyElytronHttpLocalUserProvider getInstance() {
return INSTANCE;
}
}
| 1,214
| 31.837838
| 191
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/logging/Messages.java
|
package org.infinispan.server.logging;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageBundle;
/**
* @since 10.0
*/
@MessageBundle(projectCode = "ISPN")
public interface Messages {
Messages MSG = org.jboss.logging.Messages.getBundle(Messages.class);
@Message(value = "Unrecognized command-line argument `%s`.", id = 90001)
String unknownArgument(String argument);
@Message(value = "Invalid argument `%s`. Arguments must be prefixed with either - or --.", id = 90002)
String invalidArgument(String argument);
@Message(value = "Invalid argument `%s`. The - prefix must be used only for single-character arguments.", id = 90003)
String invalidShortArgument(String command);
@Message(value = "Binds the server endpoint to a specific address.")
String serverHelpBindAddress();
@Message(value = "Binds the server to a specific port. Defaults to `%d`.")
String serverHelpBindPort(int defaultBindPort);
@Message(value = "Displays usage information and exits.")
String toolHelpHelp();
@Message("Specifies a server configuration file. Defaults to `%s`. Can be repeated, in which case the configurations are layered.")
String serverHelpServerConfig(String defaultConfiguration);
@Message("Specifies a logging configuration file. Defaults to `%s`.")
String serverHelpLoggingConfig(String defaultConfiguration);
@Message("Sets the name of the cluster. Default set by configuration expression")
String serverHelpClusterName();
@Message("Specifies the JGroups stack for clustering. Default set by configuration expression")
String serverHelpClusterStack();
@Message("Specifies the JGroups bind address for clustering.")
String serverHelpClusterAddress();
@Message("Sets the name of this node. Must be unique across the cluster.")
String serverHelpNodeName();
@Message("Adds a numeric offset to all ports.")
String serverHelpPortOffset();
@Message("Specifies the root path for the server. Defaults to `%s`.")
String toolHelpServerRoot(String defaultServerRoot);
@Message("Displays version information and exits.")
String toolHelpVersion();
@Message("Sets a system property to the specified value.")
String serverHelpProperty();
@Message("Sets system properties from the specified file.")
String serverHelpProperties();
}
| 2,373
| 36.09375
| 134
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/logging/Log.java
|
package org.infinispan.server.logging;
import java.io.IOException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.NoSuchElementException;
import javax.naming.NamingException;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.util.OS;
import org.infinispan.server.core.transport.IpSubnetFilterRule;
import org.jboss.logging.BasicLogger;
import org.jboss.logging.Logger;
import org.jboss.logging.annotations.Cause;
import org.jboss.logging.annotations.LogMessage;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageLogger;
import org.wildfly.security.auth.server.RealmUnavailableException;
/**
* @author Tristan Tarrant
* @since 10.0
*/
@MessageLogger(projectCode = "ISPN")
public interface Log extends BasicLogger {
@LogMessage(level = Logger.Level.INFO)
@Message(value = "%s Server %s starting", id = 80000)
void serverStarting(String name, String version);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "%s Server %s started in %dms", id = 80001)
void serverStarted(String name, String version, long ms);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "%s Server stopping", id = 80002)
void serverStopping(String name);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "%s Server stopped", id = 80003)
void serverStopped(String name);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Connector %s (%s) listening on %s:%d", id = 80004)
void protocolStarted(String name, String socketBinding, String host, int port);
// @Message(value = "Duplicate path '%s'", id = 80005)
// CacheConfigurationException duplicatePath(String name);
//
// @Message(value = "Duplicate network interface '%s'", id = 80006)
// CacheConfigurationException duplicateNetworkInterface(String name);
//
// @Message(value = "Duplicate socket binding '%s'", id = 80007)
// CacheConfigurationException duplicateSocketBinding(String name);
@Message(value = "Cannot instantiate protocol server configuration '%s'", id = 80008)
CacheConfigurationException cannotInstantiateProtocolServerConfigurationBuilder(Class<?> klass, @Cause Exception e);
@Message(value = "Unknown interface '%s'", id = 80009)
CacheConfigurationException unknownInterface(String interfaceName);
@Message(value = "Unknown socket binding '%s'", id = 80010)
CacheConfigurationException unknownSocketBinding(String value);
// @Message(value = "The path '%s' is not absolute", id = 80011)
// CacheConfigurationException nonAbsolutePath(String path);
//
// @Message(value = "Duplicate security domain '%s'", id = 80012)
// CacheConfigurationException duplicateSecurityRealm(String name);
//
// @Message(value = "Duplicate realm type '%s' in realm '%s'", id = 80013)
// CacheConfigurationException duplicateRealmType(String type, String name);
@Message(value = "Unknown security domain '%s'", id = 80014)
CacheConfigurationException unknownSecurityDomain(String name);
@Message(value = "Unable to load realm property files", id = 80015)
CacheConfigurationException unableToLoadRealmPropertyFiles(@Cause IOException e);
@Message(value = "No default key manager available", id = 80016)
NoSuchAlgorithmException noDefaultKeyManager();
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Server configuration: %s", id = 80017)
void serverConfiguration(String name);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Started connector %s (internal)", id = 80018)
void protocolStarted(String name);
// @LogMessage(level = Logger.Level.INFO)
// @Message(value = "Protocol Router listening on %s:%d", id = 80019)
// void routerStarted(String host, int port);
@Message(value = "Cannot use a trust store without a server identity", id = 80020)
CacheConfigurationException trustStoreWithoutServerIdentity();
@Message(value = "Authentication cannot be configured without a security realm", id = 80021)
CacheConfigurationException authenticationWithoutSecurityRealm();
@Message(value = "Cannot configure protocol encryption under a single port endpoint. Use a dedicated socket binding.", id = 80022)
CacheConfigurationException cannotConfigureProtocolEncryptionUnderSinglePort();
@Message(value = "Cannot configure a protocol with the same socket binding used by the endpoint. Use a dedicated socket binding.", id = 80023)
CacheConfigurationException protocolCannotUseSameSocketBindingAsEndpoint();
@Message(value = "Invalid URL: '%s'", id = 80024)
CacheConfigurationException invalidUrl(String url);
@Message(value = "Cannot have multiple connectors of the same type: found [%s]", id = 80025)
CacheConfigurationException multipleEndpointsSameTypeFound(String names);
@LogMessage(level = Logger.Level.WARN)
@Message(value = "Extension factory '%s' is lacking a @NamedFactory annotation", id = 80026)
void unnamedFactoryClass(String name);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Loaded extension '%s'", id = 80027)
void loadedExtension(String name);
@LogMessage(level = Logger.Level.FATAL)
@Message(value = "%s Server failed to start", id = 80028)
void serverFailedToStart(String name, @Cause Throwable t);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Cluster shutdown", id = 80029)
void clusterShutdown();
@LogMessage(level = Logger.Level.ERROR)
@Message(value = "Clustered task error", id = 80030)
void clusteredTaskError(@Cause Throwable t);
@Message(value = "Unknown server identity '%s'", id = 80031)
IllegalArgumentException unknownServerIdentity(String serverPrincipal);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Logging configuration: %s", id = 80032)
void loggingConfiguration(String absolutePath);
@Message(value = "Cannot find a network address which matches the supplied configuration", id = 80033)
CacheConfigurationException invalidNetworkConfiguration();
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Server '%s' listening on %s://%s:%d", id = 80034)
void endpointUrl(Object name, String proto, String host, int port);
@Message(value = "Unknown appender `%s`", id = 80035)
IllegalArgumentException unknownAppender(String appender);
@Message(value = "Invalid level `%s`", id = 80036)
IllegalArgumentException invalidLevel(String level);
@Message(value = "The name '%s' is already bound", id = 80037)
NamingException nameAlreadyBound(String name);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Created datasource '%s' bound to JNDI '%s'", id = 80038)
void dataSourceCreated(String name, String jndiName);
@Message(value = "Invalid Unicode sequence '%s'", id = 80039)
IOException invalidUnicodeSequence(String sequence, @Cause NoSuchElementException e);
@Message(value = "No realm name found in users property file - non-plain-text users file must contain \"#$REALM_NAME=RealmName$\" line", id = 80040)
RealmUnavailableException noRealmFoundInProperties();
@Message(value = "Duplicate data source '%s'", id = 80041)
CacheConfigurationException duplicateDataSource(String name);
@Message(value = "Duplicate JNDI name '%s'", id = 80042)
CacheConfigurationException duplicateJndiName(String jndiName);
@Message(value = "Cannot generate the server report on %s", id = 80043)
IllegalStateException serverReportUnavailable(OS os);
@LogMessage(level = Logger.Level.WARN)
@Message(value = "HotRod lazy-retrieval has been deprecated and will be removed in a future version with no direct replacement", id = 80044)
void warnHotRodLazyRetrievalDeprecated();
@LogMessage(level = Logger.Level.WARN)
@Message(value = "Overriding existing endpoint on socket-binding '%s'", id = 80045)
void endpointSocketBindingOverride(String name);
@Message(value = "Unknown credential store '%s'", id = 80046)
IllegalArgumentException unknownCredentialStore(String store);
@Message(value = "Unknown credential '%s' in store '%s'", id = 80047)
IllegalArgumentException unknownCredential(String alias, String store);
@Message(value = "A credential store name is missing", id = 80048)
IllegalArgumentException missingCredentialStoreName();
@Message(value = "A credential alias must be specified if the store doesn't contain a single alias", id = 80049)
CacheConfigurationException unspecifiedCredentialAlias();
@Message(value = "Credential reference in element '%s' would override value specified in attribute '%s'", id = 80050)
CacheConfigurationException cannotOverrideCredential(String element, String attribute);
@Message(value = "Element '%s' is missing a credential attribute '%s' or a credential reference", id = 80051)
CacheConfigurationException missingCredential(String element, String attribute);
@Message(value = "The request authentication mechanism '%s' is not supported", id = 80052)
SecurityException unsupportedMechanism(String mechName);
@Message(value = "Encryption cannot be configured without a security realm", id = 80053)
CacheConfigurationException encryptionWithoutSecurityRealm();
@Message(value = "No default trust manager available", id = 80054)
CacheConfigurationException noDefaultTrustManager();
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Connector '%s': IP filter set: %s", id = 80055)
void connectorIpFilterSet(String connector, List<IpSubnetFilterRule> rules);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Connector '%s': IP filter cleared", id = 80056)
void connectorIpFilterCleared(String connector);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Connector '%s': stopped", id = 80057)
void connectorStopped(String connector);
@LogMessage(level = Logger.Level.INFO)
@Message(value = "Connector '%s': started", id = 80058)
void connectorStarted(String connector);
@LogMessage(level = Logger.Level.WARN)
@Message(value = "No script engines are available", id = 80059)
void noScriptEngines();
@LogMessage(level = Logger.Level.INFO)
@Message(value = "SSL Transport using realm '%s`", id = 80060)
void sslTransport(String value);
@Message(value = "Realm '%s' does not provide an SSL context", id = 80061)
IllegalStateException noSSLContext(String realm);
@Message(value = "Cannot add multiple realms of type '%s' to security realm '%s'", id = 80062)
CacheConfigurationException duplicateRealmType(String type, String realm);
@Message(value = "Duplicate realm '%s'", id = 80063)
CacheConfigurationException duplicateRealm(String realmName);
@Message(value = "Unknown realm '%s'", id = 80064)
CacheConfigurationException unknownRealm(String realmName);
@Message(value = "Invalid keystore '%s'", id = 80065)
KeyStoreException invalidKeyStore(String filename);
@Message(value = "KeyStore definitions without a path must specify a type.", id = 80066)
CacheConfigurationException filelessKeyStoreRequiresType();
@Message(value = "The RESP endpoint requires a security realm which supports passwords or a trustore realm.", id = 80067)
CacheConfigurationException respEndpointRequiresRealmWithPasswordOrTrustore();
@Message(value = "Wrong masked password format", id = 80068)
CacheConfigurationException wrongMaskedPasswordFormat();
@Message(value = "Alias '%s' not in keystore '%s'", id = 80069)
CacheConfigurationException aliasNotInKeystore(String alias, String keystore);
@Message(value = "The cache container requires authorization, but none of the connectors enable authentication", id = 80070)
CacheConfigurationException authorizationWithoutAuthentication();
@Message(value = "A user mapper must be configured in order to use LDAP direct verification", id = 80071)
CacheConfigurationException ldapDirectVerificationWithoutUserMapper();
@LogMessage(level = Logger.Level.WARN)
@Message(value = "JMX remoting enabled without a default security realm. All connections will be rejected.", id = 80072)
void jmxNoDefaultSecurityRealm();
@LogMessage(level = Logger.Level.ERROR)
@Message(value = "JMX authentication error", id = 80073)
void jmxAuthenticationError(@Cause Throwable e);
@Message(value = "The Memcached endpoint text protocol requires a security realm which supports passwords.", id = 80074)
CacheConfigurationException memcachedTextEndpointRequiresRealmWithPassword();
}
| 12,603
| 44.175627
| 151
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/logging/events/PersistenceContextInitializer.java
|
package org.infinispan.server.logging.events;
import org.infinispan.marshall.persistence.PersistenceMarshaller;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
/**
* Interface used to initialise the {@link PersistenceMarshaller}'s {@link org.infinispan.protostream.SerializationContext}
* using the specified Pojos, Marshaller implementations and provided .proto schemas.
*
* @author Ryan Emerson
* @since 10.0
*/
@AutoProtoSchemaBuilder(
dependsOn = org.infinispan.marshall.persistence.impl.PersistenceContextInitializer.class,
includeClasses = ServerEventImpl.class,
schemaFileName = "persistence.event_logger.proto",
schemaFilePath = "proto/generated",
schemaPackageName = "org.infinispan.persistence.event_logger",
service = false
)
interface PersistenceContextInitializer extends SerializationContextInitializer {
}
| 954
| 38.791667
| 123
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/logging/events/ServerEventLogger.java
|
package org.infinispan.server.logging.events;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import org.infinispan.Cache;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.time.TimeService;
import org.infinispan.commons.util.Util;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.core.Search;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.remoting.transport.Address;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.util.concurrent.BlockingManager;
import org.infinispan.util.concurrent.CompletionStages;
import org.infinispan.util.logging.Log;
import org.infinispan.util.logging.LogFactory;
import org.infinispan.util.logging.events.EventLog;
import org.infinispan.util.logging.events.EventLogCategory;
import org.infinispan.util.logging.events.EventLogLevel;
import org.infinispan.util.logging.events.EventLogger;
import org.infinispan.util.logging.events.EventLoggerNotifier;
/**
* ServerEventLogger. This event logger takes care of maintaining the server event log cache and
* provides methods for querying its contents across all nodes. For resilience, the event log is
* stored in a local, bounded, persistent cache and distributed executors are used to gather logs
* from all the nodes in the cluster.
*
* @author Tristan Tarrant
* @since 8.2
*/
public class ServerEventLogger implements EventLogger {
public static final String EVENT_LOG_CACHE = "___event_log_cache";
public static final Log log = LogFactory.getLog(ServerEventLogger.class);
private final EmbeddedCacheManager cacheManager;
private final TimeService timeService;
private final EventLoggerNotifier notifier;
private final BlockingManager blockingManager;
private Cache<UUID, ServerEventImpl> eventCache;
public ServerEventLogger(EmbeddedCacheManager cacheManager, TimeService timeService, EventLoggerNotifier notifier,
BlockingManager blockingManager) {
this.cacheManager = cacheManager;
this.timeService = timeService;
this.notifier = notifier;
this.blockingManager = blockingManager;
}
@Override
public void log(EventLogLevel level, EventLogCategory category, String message) {
textLog(level, category, message);
eventLog(new ServerEventImpl(timeService.instant(), level, category, message));
}
void textLog(EventLogLevel level, EventLogCategory category, String message) {
LogFactory.getLogger(category.toString()).log(level.toLoggerLevel(), message);
}
void eventLog(ServerEventImpl event) {
if (eventCache == null) {
if (!cacheManager.isRunning(EVENT_LOG_CACHE)) {
// Cache is not running yet, we can't block this thread so offload blocking thread to log the message
blockingManager.runBlocking(() -> {
eventCache = cacheManager.getCache(EVENT_LOG_CACHE);
actualSend(eventCache, event);
}, "ServerEventLog");
return;
}
eventCache = cacheManager.getCache(EVENT_LOG_CACHE);
}
actualSend(eventCache, event);
}
void actualSend(Cache<UUID, ServerEventImpl> cache, ServerEventImpl event) {
eventCache.putAsync(Util.threadLocalRandomUUID(), event)
.thenAccept(ignore -> CompletionStages.join(notifier.notifyEventLogged(event)));
}
@Override
public EventLogger scope(Address scope) {
return new DecoratedServerEventLogger(this).scope(scope);
}
@Override
public EventLogger scope(String scope) {
return new DecoratedServerEventLogger(this).scope(scope);
}
@Override
public EventLogger context(String cacheName) {
return new DecoratedServerEventLogger(this).context(cacheName);
}
@Override
public EventLogger detail(String detail) {
return new DecoratedServerEventLogger(this).detail(detail);
}
@Override
public EventLogger who(String s) {
return new DecoratedServerEventLogger(this).who(s);
}
TimeService getTimeService() {
return timeService;
}
@Override
public List<EventLog> getEvents(Instant start, int count, Optional<EventLogCategory> category, Optional<EventLogLevel> level) {
List<EventLog> events = Collections.synchronizedList(new ArrayList<>());
AtomicReference<Throwable> throwable = new AtomicReference<>();
try {
SecurityActions.getClusterExecutor(cacheManager).submitConsumer(m -> {
Cache<Object, Object> cache = m.getCache(EVENT_LOG_CACHE);
String queryStr = "FROM " + ServerEventImpl.class.getName()+ " WHERE when <= :when"; //todo [anistor] is start parameter supposed to indicate before or after?
if (category.isPresent()) {
queryStr += " AND category = :category";
}
if (level.isPresent()) {
queryStr += " AND level = :level";
}
queryStr += " ORDER BY when DESC";
QueryFactory queryFactory = Search.getQueryFactory(cache);
Query<EventLog> query = queryFactory.create(queryStr);
query.maxResults(count);
query.setParameter("when", start);
category.ifPresent(c -> query.setParameter("category", c));
level.ifPresent(l -> query.setParameter("level", l));
return query.execute().list();
}, (address, nodeEvents, t) -> {
if (t == null) {
events.addAll(nodeEvents);
} else {
throwable.set(t);
}
}).get(1, TimeUnit.MINUTES);
Throwable th = throwable.get();
if (th != null) {
throw new CacheException(th);
}
} catch (CacheException e) {
log.debug("Could not retrieve events", e);
throw e;
} catch (Exception e) {
log.debug("Could not retrieve events", e);
throw new CacheException(e);
}
// must sort and limit again the distributed results
Collections.sort(events);
return count > 0
? events.subList(0, Math.min(events.size(), count))
: events;
}
@Override
public CompletionStage<Void> addListenerAsync(Object listener) {
return notifier.addListenerAsync(listener);
}
@Override
public CompletionStage<Void> removeListenerAsync(Object listener) {
return notifier.removeListenerAsync(listener);
}
@Override
public Set<Object> getListeners() {
return notifier.getListeners();
}
}
| 6,854
| 36.459016
| 173
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/logging/events/DecoratedServerEventLogger.java
|
package org.infinispan.server.logging.events;
import org.infinispan.util.logging.events.EventLogCategory;
import org.infinispan.util.logging.events.EventLogLevel;
import org.infinispan.util.logging.events.impl.DecoratedEventLogger;
/**
* DecoratedServerEventLogger. Provides a way to decorate an EventLog with additional information.
*
* @author Tristan Tarrant
* @since 8.2
*/
class DecoratedServerEventLogger extends DecoratedEventLogger {
private final ServerEventLogger delegate;
DecoratedServerEventLogger(ServerEventLogger delegate) {
super(delegate);
this.delegate = delegate;
}
@Override
public void log(EventLogLevel level, EventLogCategory category, String message) {
StringBuilder sb = new StringBuilder();
addLogsToBuilder(sb);
// We don't include detail in this implementation
sb.append(message);
delegate.textLog(level, category, sb.toString());
delegate.eventLog(new ServerEventImpl(delegate.getTimeService().instant(), level, category, message, detail, context, who, scope));
}
}
| 1,072
| 32.53125
| 137
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/logging/events/ServerEventImpl.java
|
package org.infinispan.server.logging.events;
import java.time.Instant;
import java.util.Optional;
import org.infinispan.commons.marshall.ProtoStreamTypeIds;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.protostream.annotations.ProtoTypeId;
import org.infinispan.util.logging.events.EventLogCategory;
import org.infinispan.util.logging.events.EventLogLevel;
import org.infinispan.util.logging.events.impl.BaseEventLog;
/**
* ServerEvent.
*
* @author Tristan Tarrant
* @since 8.2
*/
@ProtoTypeId(ProtoStreamTypeIds.SERVER_EVENT_IMPL)
public final class ServerEventImpl extends BaseEventLog {
@ProtoFactory
ServerEventImpl(long whenMs, EventLogLevel level, EventLogCategory category, String message, String detail, String context, String who, String scope) {
this(Instant.ofEpochMilli(whenMs), level, category, message, detail, context, who, scope);
}
ServerEventImpl(Instant when, EventLogLevel level, EventLogCategory category, String message, String detail, String context, String who, String scope) {
super(when, level, category, message, detail, context, who, scope);
}
ServerEventImpl(Instant when, EventLogLevel level, EventLogCategory category, String message) {
this(when, level, category, message, null, null, null, null);
}
/**
* Milliseconds since epoch.
*/
@ProtoField(number = 1, name = "when", defaultValue = "0")
long getWhenMs() {
return when.toEpochMilli();
}
@ProtoField(2)
@Override
public EventLogLevel getLevel() {
return level;
}
@ProtoField(3)
@Override
public EventLogCategory getCategory() {
return category;
}
@ProtoField(4)
@Override
public String getMessage() {
return message;
}
@ProtoField(5)
@Override
public Optional<String> getDetail() {
return Optional.ofNullable(detail);
}
@ProtoField(6)
@Override
public Optional<String> getWho() {
return Optional.ofNullable(who);
}
@ProtoField(7)
@Override
public Optional<String> getContext() {
return Optional.ofNullable(context);
}
@ProtoField(8)
@Override
public Optional<String> getScope() {
return Optional.ofNullable(scope);
}
@Override
public String toString() {
return "ServerEventImpl{" +
"when=" + when +
", level=" + level +
", category=" + category +
", message='" + message + '\'' +
", detail=" + detail +
", context=" + context +
", who=" + who +
", scope=" + scope +
'}';
}
}
| 2,690
| 26.181818
| 155
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/logging/log4j/XmlConfigurationFactory.java
|
package org.infinispan.server.logging.log4j;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.apache.logging.log4j.core.config.ConfigurationSource;
import org.apache.logging.log4j.core.config.Order;
import org.apache.logging.log4j.core.config.plugins.Plugin;
@Plugin(name = "XmlConfigurationFactory", category = ConfigurationFactory.CATEGORY)
@Order(5)
public class XmlConfigurationFactory extends ConfigurationFactory {
/**
* Valid file extensions for XML files.
*/
public static final String[] SUFFIXES = new String[] {".xml", "*"};
/**
* Returns the Configuration.
* @param loggerContext The logger context.
* @param source The InputSource.
* @return The Configuration.
*/
@Override
public Configuration getConfiguration(final LoggerContext loggerContext, final ConfigurationSource source) {
return new XmlConfiguration(loggerContext, source);
}
/**
* Returns the file suffixes for XML files.
* @return An array of File extensions.
*/
@Override
public String[] getSupportedTypes() {
return SUFFIXES;
}
}
| 1,257
| 31.25641
| 112
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/logging/log4j/XmlConfiguration.java
|
package org.infinispan.server.logging.log4j;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.AbstractConfiguration;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.ConfigurationSource;
import org.apache.logging.log4j.core.config.Node;
import org.apache.logging.log4j.core.config.Reconfigurable;
import org.apache.logging.log4j.core.config.plugins.util.PluginType;
import org.apache.logging.log4j.core.config.plugins.util.ResolverUtil;
import org.apache.logging.log4j.core.config.status.StatusConfiguration;
import org.apache.logging.log4j.core.util.Patterns;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.parsing.ParseUtils;
public class XmlConfiguration extends AbstractConfiguration implements Reconfigurable {
private static final String[] VERBOSE_CLASSES = new String[]{ResolverUtil.class.getName()};
private final List<Status> status = new ArrayList<>();
public XmlConfiguration(final LoggerContext loggerContext, final ConfigurationSource configSource) {
super(loggerContext, configSource);
}
private void parseConfiguration(ConfigurationReader reader) {
StatusConfiguration statusConfig = new StatusConfiguration().withVerboseClasses(VERBOSE_CLASSES)
.withStatus(getDefaultStatus());
int monitorIntervalSeconds = 0;
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
switch (reader.getAttributeName(i).toLowerCase()) {
case "status":
statusConfig.withStatus(value);
break;
case "dest":
statusConfig.withDestination(value);
break;
case "shutdownhook":
isShutdownHookEnabled = !"disable".equals(value);
break;
case "shutdowntimeout":
shutdownTimeoutMillis = Long.parseLong(value);
break;
case "verbose":
statusConfig.withVerbosity(value);
break;
case "packages":
pluginPackages.addAll(Arrays.asList(value.split(Patterns.COMMA_SEPARATOR)));
break;
case "name":
setName(value);
break;
case "strict":
case "schema":
break;
case "monitorinterval":
monitorIntervalSeconds = Integer.parseInt(value);
break;
case "advertiser":
//createAdvertiser(value, getConfigurationSource(), buffer, "text/xml");
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
initializeWatchers(this, getConfigurationSource(), monitorIntervalSeconds);
statusConfig.initialize();
if (getName() == null) {
setName(getConfigurationSource().getLocation());
}
parseElement(reader, rootNode);
}
@Override
public void setup() {
final File configFile = getConfigurationSource().getFile();
try (InputStream configStream = Files.newInputStream(configFile.toPath())) {
ConfigurationReader reader = ConfigurationReader.from(configStream).withProperties(System.getProperties()).withReplacer((string, props) -> getStrSubstitutor().replace(string)).withType(MediaType.APPLICATION_XML).build();
reader.require(ConfigurationReader.ElementType.START_DOCUMENT);
reader.nextElement();
reader.require(ConfigurationReader.ElementType.START_ELEMENT, null, "Configuration");
parseConfiguration(reader);
while (reader.nextElement() != ConfigurationReader.ElementType.END_DOCUMENT) {
// consume remaining parsing events
}
} catch (IOException e) {
throw new CacheConfigurationException(e);
}
if (status.size() > 0) {
for (final Status s : status) {
LOGGER.error("Error processing element {} ({}): {}", s.name, s.element, s.errorType);
}
return;
}
}
@Override
public Configuration reconfigure() {
try {
final ConfigurationSource source = getConfigurationSource().resetInputStream();
if (source == null) {
return null;
}
return new XmlConfiguration(getLoggerContext(), source);
} catch (final IOException ex) {
LOGGER.error("Cannot locate file {}", getConfigurationSource(), ex);
}
return null;
}
private void parseElement(ConfigurationReader reader, Node node) {
processAttributes(reader, node);
final List<Node> children = node.getChildren();
while (reader.inTag()) {
String name = reader.getLocalName();
PluginType<?> type = pluginManager.getPluginType(name);
Node childNode = new Node(node, name, type);
switch (name.toLowerCase()) {
case "property":
processAttributes(reader, childNode);
childNode.setValue(reader.getElementText().trim());
children.add(childNode);
break;
default:
parseElement(reader, childNode);
if (type == null) {
final String value = childNode.getValue();
if (!childNode.hasChildren() && value != null) {
node.getAttributes().put(name, value);
} else {
status.add(new Status(name, name, ErrorType.CLASS_NOT_FOUND));
}
} else {
children.add(childNode);
}
}
}
}
private void processAttributes(ConfigurationReader reader, Node node) {
final Map<String, String> attributes = node.getAttributes();
for (int i = 0; i < reader.getAttributeCount(); i++) {
attributes.put(reader.getAttributeName(i), reader.getAttributeValue(i));
}
}
/**
* The error that occurred.
*/
private enum ErrorType {
CLASS_NOT_FOUND
}
/**
* Status for recording errors.
*/
private static class Status {
private final String element;
private final String name;
private final ErrorType errorType;
public Status(final String name, final String element, final ErrorType errorType) {
this.name = name;
this.element = element;
this.errorType = errorType;
}
@Override
public String toString() {
return "Status [name=" + name + ", element=" + element + ", errorType=" + errorType + "]";
}
}
}
| 7,021
| 36.351064
| 229
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/state/PersistenceContextInitializer.java
|
package org.infinispan.server.state;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
/**
* Interface used to initialise a {@link org.infinispan.protostream.SerializationContext} using the specified Pojos,
* Marshaller implementations and provided .proto schemas.
*
* @author Tristan Tarrant
* @since 12.1
*/
@AutoProtoSchemaBuilder(
includeClasses = {
ServerStateManagerImpl.IgnoredCaches.class,
ServerStateManagerImpl.IpFilterRules.class,
ServerStateManagerImpl.IpFilterRule.class,
},
schemaFileName = "persistence.server_state.proto",
schemaFilePath = "proto/generated",
schemaPackageName = "org.infinispan.persistence.server_state",
service = false
)
interface PersistenceContextInitializer extends SerializationContextInitializer {
}
| 907
| 33.923077
| 116
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/state/ServerStateManagerImpl.java
|
package org.infinispan.server.state;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentHashMap;
import org.infinispan.Cache;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.marshall.ProtoStreamTypeIds;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.globalstate.GlobalConfigurationManager;
import org.infinispan.globalstate.ScopeFilter;
import org.infinispan.globalstate.ScopedState;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryCreated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryModified;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved;
import org.infinispan.notifications.cachelistener.event.CacheEntryCreatedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryModifiedEvent;
import org.infinispan.notifications.cachelistener.event.CacheEntryRemovedEvent;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.protostream.annotations.ProtoTypeId;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.Security;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.Server;
import org.infinispan.server.core.ProtocolServer;
import org.infinispan.server.core.ServerManagement;
import org.infinispan.server.core.ServerStateManager;
import org.infinispan.server.core.transport.CompositeChannelMatcher;
import org.infinispan.server.core.transport.ConnectionMetadata;
import org.infinispan.server.core.transport.IpFilterRuleChannelMatcher;
import org.infinispan.server.core.transport.IpSubnetFilterRule;
import org.infinispan.server.core.transport.Transport;
import io.netty.channel.group.ChannelGroup;
import io.netty.handler.ipfilter.IpFilterRuleType;
import io.netty.handler.ssl.SslHandler;
/**
* Manages cluster-wide server state for a given {@link EmbeddedCacheManager}. This handles:
* <ul>
* <li>ignored caches</li>
* <li>protocol servers</li>
* <li>ip filters</li>
* </ul>
*
* @since 12.1
*/
public final class ServerStateManagerImpl implements ServerStateManager {
private static final String CONNECTOR_STATE_SCOPE = "connector-state";
private static final String CONNECTOR_IPFILTER_SCOPE = "connector-ipfilter";
private static final ScopedState IGNORED_CACHES_KEY = new ScopedState("ignored-caches", "ignored-caches");
private final EmbeddedCacheManager cacheManager;
private final Server server;
private final Cache<ScopedState, Object> cache;
private final IgnoredCaches ignored = new IgnoredCaches();
private volatile boolean hasIgnores;
public ServerStateManagerImpl(Server server, EmbeddedCacheManager cacheManager, GlobalConfigurationManager configurationManager) {
this.server = server;
this.cacheManager = cacheManager;
this.cache = configurationManager.getStateCache();
}
@Override
public void start() {
updateLocalIgnoredCaches((IgnoredCaches) cache.get(IGNORED_CACHES_KEY));
// Register the listeners which will react on
cache.addListener(new IgnoredCachesListener(), new ScopeFilter(IGNORED_CACHES_KEY.getScope()), null);
cache.addListener(new ConnectorStateListener(), new ScopeFilter(CONNECTOR_STATE_SCOPE), null);
cache.addListener(new ConnectorIpFilterListener(), new ScopeFilter(CONNECTOR_IPFILTER_SCOPE), null);
}
@Override
public void stop() {
}
@Override
public CompletableFuture<Void> unignoreCache(String cacheName) {
SecurityActions.checkPermission(cacheManager, AuthorizationPermission.ADMIN);
synchronized (this) {
ignored.caches.remove(cacheName);
hasIgnores = !ignored.caches.isEmpty();
return cache.putAsync(IGNORED_CACHES_KEY, ignored).thenApply(r -> null);
}
}
@Override
public CompletableFuture<Void> ignoreCache(String cacheName) {
SecurityActions.checkPermission(cacheManager, AuthorizationPermission.ADMIN);
synchronized (this) {
ignored.caches.add(cacheName);
hasIgnores = true;
return cache.putAsync(IGNORED_CACHES_KEY, ignored).thenApply(r -> null);
}
}
@Override
public Set<String> getIgnoredCaches() {
return Collections.unmodifiableSet(ignored.caches);
}
@Override
public boolean isCacheIgnored(String cacheName) {
return hasIgnores && ignored.caches.contains(cacheName);
}
@Override
public CompletableFuture<Boolean> connectorStart(String name) {
SecurityActions.checkPermission(cacheManager, AuthorizationPermission.ADMIN);
return cache.removeAsync(new ScopedState(CONNECTOR_STATE_SCOPE, name), true).thenApply(v -> null);
}
@Override
public CompletableFuture<Void> connectorStop(String name) {
SecurityActions.checkPermission(cacheManager, AuthorizationPermission.ADMIN);
return cache.putAsync(new ScopedState(CONNECTOR_STATE_SCOPE, name), true).thenApply(v -> null);
}
@Override
public CompletableFuture<Boolean> connectorStatus(String name) {
SecurityActions.checkPermission(cacheManager, AuthorizationPermission.ADMIN);
return cache.containsKeyAsync(new ScopedState(CONNECTOR_STATE_SCOPE, name)).thenApply(v -> !v);
}
@Override
public CompletableFuture<Void> setConnectorIpFilterRule(String name, Collection<IpSubnetFilterRule> filterRule) {
SecurityActions.checkPermission(cacheManager, AuthorizationPermission.ADMIN);
IpFilterRules ipFilterRules = new IpFilterRules();
filterRule.forEach(r -> ipFilterRules.rules.add(new IpFilterRule(r)));
return cache.putAsync(new ScopedState(CONNECTOR_IPFILTER_SCOPE, name), ipFilterRules).thenApply(v -> null);
}
@Override
public CompletableFuture<Void> clearConnectorIpFilterRules(String name) {
SecurityActions.checkPermission(cacheManager, AuthorizationPermission.ADMIN);
return cache.putAsync(new ScopedState(CONNECTOR_IPFILTER_SCOPE, name), new IpFilterRules()).thenApply(v -> null);
}
@Override
public CompletableFuture<Json> listConnections() {
Json r = Json.array();
for (Map.Entry<String, ProtocolServer> ps : server.getProtocolServers().entrySet()) {
Transport transport = ps.getValue().getTransport();
if (transport != null) {
ChannelGroup channels = transport.getAcceptedChannels();
channels.forEach(ch -> {
ConnectionMetadata metadata = ConnectionMetadata.getInstance(ch);
Json o = Json.object();
o.set("id", metadata.id());
o.set("server-node-name", server.getCacheManager().getAddress().toString());
o.set("name", metadata.clientName());
o.set("created", metadata.created());
o.set("principal", Security.getSubjectUserPrincipalName(metadata.subject()));
o.set("local-address", metadata.localAddress().toString());
o.set("remote-address", metadata.remoteAddress().toString());
o.set("protocol-version", metadata.protocolVersion());
o.set("client-library", metadata.clientLibraryName());
o.set("client-version", metadata.clientLibraryVersion());
SslHandler ssl = ch.pipeline().get(SslHandler.class);
if (ssl != null) {
o.set("ssl-application-protocol", ssl.applicationProtocol());
o.set("ssl-cipher-suite", ssl.engine().getSession().getCipherSuite());
o.set("ssl-protocol", ssl.engine().getSession().getProtocol());
}
r.add(o);
});
}
}
return CompletableFuture.completedFuture(r);
}
@Override
public ServerManagement managedServer() {
return server;
}
private void updateLocalIgnoredCaches(IgnoredCaches ignored) {
if (ignored != null) {
synchronized (this) {
this.ignored.caches.clear();
this.ignored.caches.addAll(ignored.caches);
hasIgnores = !this.ignored.caches.isEmpty();
}
}
}
private CompletionStage<Void> updateIpFilters(String connector, Collection<IpFilterRule> rules) {
ProtocolServer<?> protocolServer = server.getProtocolServers().get(connector);
if (rules.isEmpty()) {
protocolServer.getConfiguration().ipFilter().rules(Collections.emptyList());
Server.log.connectorIpFilterCleared(connector);
return CompletableFutures.completedNull();
} else {
List<IpSubnetFilterRule> localRules = new ArrayList<>(rules.size());
for (IpFilterRule rule : rules) {
localRules.add(new IpSubnetFilterRule(rule.cidr, IpFilterRuleType.valueOf(rule.type)));
}
protocolServer.getConfiguration().ipFilter().rules(localRules);
Transport transport = getTransport(protocolServer);
CompositeChannelMatcher matcher = new CompositeChannelMatcher(protocolServer.getChannelMatcher(), new IpFilterRuleChannelMatcher(localRules));
return transport.closeChannels(matcher).thenApply(v -> {
Server.log.connectorIpFilterSet(connector, localRules);
return v;
});
}
}
@Listener(observation = Listener.Observation.POST, includeCurrentState = true, clustered = true)
private final class IgnoredCachesListener {
@CacheEntryCreated
public void created(CacheEntryCreatedEvent<ScopedState, IgnoredCaches> e) {
if (!e.isOriginLocal()) {
updateLocalIgnoredCaches(e.getValue());
}
}
@CacheEntryModified
public void modified(CacheEntryModifiedEvent<ScopedState, IgnoredCaches> e) {
if (!e.isOriginLocal()) {
updateLocalIgnoredCaches(e.getValue());
}
}
}
@Listener(observation = Listener.Observation.POST, includeCurrentState = true, clustered = true)
private final class ConnectorStateListener {
@CacheEntryCreated
public CompletionStage<Void> created(CacheEntryCreatedEvent<ScopedState, Boolean> e) {
// stop the connector
String connector = e.getKey().getName();
ProtocolServer protocolServer = server.getProtocolServers().get(connector);
protocolServer.getConfiguration().disable();
// Close all active connections
Transport transport = getTransport(protocolServer);
return transport.closeChannels(protocolServer.getChannelMatcher()).thenApply(v -> {
Server.log.connectorStopped(connector);
return v;
});
}
@CacheEntryRemoved
public void removed(CacheEntryRemovedEvent<ScopedState, Boolean> e) {
// start the connector
String connector = e.getKey().getName();
server.getProtocolServers().get(connector).getConfiguration().enable();
Server.log.connectorStarted(connector);
}
}
private Transport getTransport(ProtocolServer protocolServer) {
Transport transport = protocolServer.getTransport();
if (transport == null) {
transport = protocolServer.getEnclosingProtocolServer().getTransport();
}
return transport;
}
@Listener(observation = Listener.Observation.POST, includeCurrentState = true, clustered = true)
private final class ConnectorIpFilterListener {
@CacheEntryCreated
@CacheEntryModified
public CompletionStage<Void> modified(CacheEntryEvent<ScopedState, IpFilterRules> e) {
return updateIpFilters(e.getKey().getName(), e.getValue().rules);
}
}
@ProtoTypeId(ProtoStreamTypeIds.IGNORED_CACHES)
static final class IgnoredCaches {
@ProtoField(number = 1, collectionImplementation = HashSet.class)
final Set<String> caches;
IgnoredCaches() {
this(ConcurrentHashMap.newKeySet());
}
@ProtoFactory
IgnoredCaches(Set<String> caches) {
// ProtoStream cannot use KeySetView directly as it does not have a zero args constructor
this.caches = ConcurrentHashMap.newKeySet(caches.size());
this.caches.addAll(caches);
}
@Override
public String toString() {
return "IgnoredCaches" + caches;
}
}
@ProtoTypeId(ProtoStreamTypeIds.IP_FILTER_RULE)
static final class IpFilterRule {
@ProtoField(number = 1)
final String cidr;
@ProtoField(number = 2)
final String type;
@ProtoFactory
IpFilterRule(String cidr, String type) {
this.cidr = cidr;
this.type = type;
}
IpFilterRule(IpSubnetFilterRule filterRule) {
this(filterRule.cidr(), filterRule.ruleType().name());
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
IpFilterRule that = (IpFilterRule) o;
return cidr.equals(that.cidr) && type.equals(that.type);
}
@Override
public int hashCode() {
return Objects.hash(cidr, type);
}
}
@ProtoTypeId(ProtoStreamTypeIds.IP_FILTER_RULES)
static final class IpFilterRules {
@ProtoField(number = 1, collectionImplementation = LinkedHashSet.class)
final Set<IpFilterRule> rules;
IpFilterRules() {
this(new LinkedHashSet<>());
}
@ProtoFactory
IpFilterRules(Set<IpFilterRule> rules) {
this.rules = new LinkedHashSet<>(rules.size());
this.rules.addAll(rules);
}
}
}
| 14,095
| 38.595506
| 151
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/network/SocketBinding.java
|
package org.infinispan.server.network;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class SocketBinding {
private final String name;
private final NetworkAddress address;
private final int port;
public SocketBinding(String name, NetworkAddress networkAddress, int port) {
this.name = name;
this.address = networkAddress;
this.port = port;
}
public NetworkAddress getAddress() {
return address;
}
public int getPort() {
return port;
}
public String getName() {
return name;
}
public String toString() {
return "SocketBinding{" +
"name='" + name + '\'' +
", address=" + address +
", port=" + port +
'}';
}
}
| 785
| 19.684211
| 79
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/network/NetworkAddress.java
|
package org.infinispan.server.network;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.net.UnknownHostException;
import java.util.Enumeration;
import java.util.function.Predicate;
import org.infinispan.server.Server;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class NetworkAddress {
static final int[] NETMASK_BY_PREFIX = { 0, 128, 192, 224, 240, 248, 252, 254, 255};
private final String name;
private final InetAddress address;
private final short prefixLength;
NetworkAddress(String name, InterfaceAddress address) {
this.name = name;
this.address = address.getAddress();
this.prefixLength = address.getNetworkPrefixLength();
}
NetworkAddress(String name, InetAddress address) {
this.name = name;
this.address = address;
this.prefixLength = 0;
}
/**
* The name of this address
*/
public String getName() {
return name;
}
/**
* The IP address
*/
public InetAddress getAddress() {
return address;
}
public String cidr() {
StringBuilder sb = new StringBuilder();
byte[] bytes = address.getAddress();
short prefix = prefixLength;
for (int i = 0; i < bytes.length; i++) {
if (i > 0) {
sb.append('.');
}
int bits = prefix > 8 ? 8 : prefix;
sb.append((int)bytes[i] & NETMASK_BY_PREFIX[bits]);
prefix -= bits;
}
sb.append('/').append(prefixLength);
return sb.toString();
}
@Override
public String toString() {
return "NetworkAddress{" +
"name='" + name + '\'' +
", address=" + address +
", prefixLength=" + prefixLength +
'}';
}
public short getPrefixLength() {
return prefixLength;
}
public static NetworkAddress fromString(String name, String value) throws IOException {
switch (value) {
case "GLOBAL":
return globalAddress(name);
case "LOOPBACK":
return loopback(name);
case "NON_LOOPBACK":
return nonLoopback(name);
case "SITE_LOCAL":
return siteLocal(name);
case "LINK_LOCAL":
return linkLocalAddress(name);
default:
if (value.startsWith("match-interface:")) {
return matchInterface(name, value.substring(value.indexOf(':') + 1));
} else if (value.startsWith("match-address:")) {
return matchAddress(name, value.substring(value.indexOf(':') + 1));
} else if (value.startsWith("match-host:")) {
return matchHost(name, value.substring(value.indexOf(':') + 1));
} else {
return inetAddress(name, value);
}
}
}
public static NetworkAddress globalAddress(String name) throws IOException {
return new NetworkAddress(name, findAddress(a -> !a.getAddress().isLoopbackAddress() && !a.getAddress().isSiteLocalAddress() && !a.getAddress().isLinkLocalAddress()));
}
public static NetworkAddress loopback(String name) throws IOException {
return new NetworkAddress(name, findAddress(a -> a.getAddress().isLoopbackAddress()));
}
public static NetworkAddress nonLoopback(String name) throws IOException {
return new NetworkAddress(name, findAddress(a -> !a.getAddress().isLoopbackAddress()));
}
public static NetworkAddress siteLocal(String name) throws IOException {
return new NetworkAddress(name, findAddress(a -> a.getAddress().isSiteLocalAddress()));
}
public static NetworkAddress matchInterface(String name, String regex) throws IOException {
return new NetworkAddress(name, findInterface(i -> i.getName().matches(regex)).getInterfaceAddresses().get(0));
}
public static NetworkAddress matchAddress(String name, String regex) throws IOException {
return new NetworkAddress(name, findAddress(a -> a.getAddress().getHostAddress().matches(regex)));
}
public static NetworkAddress matchHost(String name, String regex) throws IOException {
return new NetworkAddress(name, findAddress(a -> a.getAddress().getHostName().matches(regex)));
}
public static NetworkAddress match(String name, Predicate<NetworkInterface> ifMatcher, Predicate<InterfaceAddress> addressMatcher) throws IOException {
for (Enumeration<java.net.NetworkInterface> interfaces = java.net.NetworkInterface.getNetworkInterfaces(); interfaces.hasMoreElements(); ) {
NetworkInterface networkInterface = interfaces.nextElement();
if (networkInterface.isUp()) {
if (ifMatcher.test(networkInterface)) {
InterfaceAddress address = findAddress(networkInterface, addressMatcher);
if (address != null) {
return new NetworkAddress(name, address);
}
}
}
}
throw new IOException("No matching addresses found");
}
public static NetworkAddress inetAddress(String name, String value) throws UnknownHostException {
return new NetworkAddress(name, InetAddress.getByName(value));
}
public static NetworkAddress anyAddress(String name) throws UnknownHostException {
return new NetworkAddress(name, InetAddress.getByAddress(new byte[]{0, 0, 0, 0}));
}
public static NetworkAddress linkLocalAddress(String name) throws IOException {
return new NetworkAddress(name, findAddress(a -> a.getAddress().isLinkLocalAddress()));
}
private static InterfaceAddress findAddress(Predicate<InterfaceAddress> matcher) throws IOException {
for (Enumeration<java.net.NetworkInterface> interfaces = java.net.NetworkInterface.getNetworkInterfaces(); interfaces.hasMoreElements(); ) {
NetworkInterface networkInterface = interfaces.nextElement();
if (networkInterface.isUp()) {
if (Server.log.isDebugEnabled()) {
Server.log.debugf("Network interface %s", networkInterface);
}
InterfaceAddress ifAddress = findAddress(networkInterface, matcher);
if (ifAddress != null) return ifAddress;
}
}
throw new IOException("No matching addresses found");
}
private static InterfaceAddress findAddress(NetworkInterface networkInterface, Predicate<InterfaceAddress> matcher) {
for (InterfaceAddress ifAddress : networkInterface.getInterfaceAddresses()) {
InetAddress address = ifAddress.getAddress();
if (Server.log.isDebugEnabled()) {
Server.log.debugf("Network address %s (loopback=%b linklocal=%b sitelocal=%b)", address, address.isLoopbackAddress(), address.isLinkLocalAddress(), address.isSiteLocalAddress());
}
if (matcher.test(ifAddress)) {
return ifAddress;
}
}
return null;
}
private static NetworkInterface findInterface(Predicate<NetworkInterface> matcher) throws IOException {
for (Enumeration<java.net.NetworkInterface> interfaces = java.net.NetworkInterface.getNetworkInterfaces(); interfaces.hasMoreElements(); ) {
NetworkInterface networkInterface = interfaces.nextElement();
if (networkInterface.isUp()) {
if (Server.log.isDebugEnabled()) {
Server.log.debugf("Network interface %s", networkInterface);
}
if (matcher.test(networkInterface)) {
return networkInterface;
}
}
}
throw new IOException("No matching addresses found");
}
}
| 7,651
| 36.694581
| 190
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/context/ServerInitialContextFactory.java
|
package org.infinispan.server.context;
import java.util.Hashtable;
import java.util.concurrent.ConcurrentMap;
import javax.naming.Context;
import javax.naming.spi.InitialContextFactory;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class ServerInitialContextFactory implements InitialContextFactory {
private final ConcurrentMap<String, Object> namedObjects;
public ServerInitialContextFactory(ConcurrentMap<String, Object> namedObjects) {
this.namedObjects = namedObjects;
}
@Override
public Context getInitialContext(Hashtable<?, ?> environment) {
return new ServerInitialContext(namedObjects);
}
}
| 680
| 25.192308
| 83
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/context/ServerInitialContext.java
|
package org.infinispan.server.context;
import java.util.Hashtable;
import java.util.concurrent.ConcurrentMap;
import javax.naming.Binding;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.NameClassPair;
import javax.naming.NameParser;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import org.infinispan.server.Server;
/**
* A very trivial implementation of {@link Context} which only supports binding and lookup in a flat namespace
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class ServerInitialContext implements Context {
private final ConcurrentMap<String, Object> namedObjects;
public ServerInitialContext(ConcurrentMap<String, Object> namedObjects) {
this.namedObjects = namedObjects;
}
@Override
public Object lookup(Name name) {
return lookup(name.toString());
}
@Override
public Object lookup(String name) {
return namedObjects.get(name);
}
@Override
public void bind(Name name, Object obj) throws NamingException {
bind(name.toString(), obj);
}
@Override
public void bind(String name, Object obj) throws NamingException {
if (namedObjects.putIfAbsent(name, obj) != null) {
throw Server.log.nameAlreadyBound(name);
}
}
@Override
public void rebind(Name name, Object obj) {
throw new UnsupportedOperationException();
}
@Override
public void rebind(String name, Object obj) {
throw new UnsupportedOperationException();
}
@Override
public void unbind(Name name) {
throw new UnsupportedOperationException();
}
@Override
public void unbind(String name) {
throw new UnsupportedOperationException();
}
@Override
public void rename(Name oldName, Name newName) {
throw new UnsupportedOperationException();
}
@Override
public void rename(String oldName, String newName) {
throw new UnsupportedOperationException();
}
@Override
public NamingEnumeration<NameClassPair> list(Name name) {
throw new UnsupportedOperationException();
}
@Override
public NamingEnumeration<NameClassPair> list(String name) {
throw new UnsupportedOperationException();
}
@Override
public NamingEnumeration<Binding> listBindings(Name name) {
throw new UnsupportedOperationException();
}
@Override
public NamingEnumeration<Binding> listBindings(String name) {
throw new UnsupportedOperationException();
}
@Override
public void destroySubcontext(Name name) {
throw new UnsupportedOperationException();
}
@Override
public void destroySubcontext(String name) {
throw new UnsupportedOperationException();
}
@Override
public Context createSubcontext(Name name) {
throw new UnsupportedOperationException();
}
@Override
public Context createSubcontext(String name) {
throw new UnsupportedOperationException();
}
@Override
public Object lookupLink(Name name) {
throw new UnsupportedOperationException();
}
@Override
public Object lookupLink(String name) {
throw new UnsupportedOperationException();
}
@Override
public NameParser getNameParser(Name name) {
throw new UnsupportedOperationException();
}
@Override
public NameParser getNameParser(String name) {
throw new UnsupportedOperationException();
}
@Override
public Name composeName(Name name, Name prefix) {
throw new UnsupportedOperationException();
}
@Override
public String composeName(String name, String prefix) {
throw new UnsupportedOperationException();
}
@Override
public Object addToEnvironment(String propName, Object propVal) {
throw new UnsupportedOperationException();
}
@Override
public Object removeFromEnvironment(String propName) {
throw new UnsupportedOperationException();
}
@Override
public Hashtable<?, ?> getEnvironment() {
return null;
}
@Override
public void close() {
// Do nothing
}
@Override
public String getNameInNamespace() {
throw new UnsupportedOperationException();
}
}
| 4,222
| 22.858757
| 110
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/context/ServerInitialContextFactoryBuilder.java
|
package org.infinispan.server.context;
import java.io.Closeable;
import java.util.Hashtable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.spi.InitialContextFactory;
import javax.naming.spi.InitialContextFactoryBuilder;
import org.infinispan.commons.util.ServiceFinder;
import org.infinispan.commons.util.Util;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class ServerInitialContextFactoryBuilder implements InitialContextFactoryBuilder, Closeable {
private final ConcurrentMap<String, Object> namedObjects;
private final Map<String, InitialContextFactory> initialContextFactories;
public ServerInitialContextFactoryBuilder() {
namedObjects = new ConcurrentHashMap<>();
initialContextFactories = ServiceFinder.load(InitialContextFactory.class, Thread.currentThread().getContextClassLoader()).stream().collect(Collectors.toMap(className(), Function.identity()));
}
@Override
public InitialContextFactory createInitialContextFactory(Hashtable<?, ?> environment) throws NamingException {
String className = environment != null ? (String) environment.get(Context.INITIAL_CONTEXT_FACTORY) : null;
if (className == null) {
return new ServerInitialContextFactory(namedObjects);
}
if (initialContextFactories.containsKey(className)) {
return initialContextFactories.get(className);
} else {
return InitialContextFactory.class.cast(Util.getInstance(className, Thread.currentThread().getContextClassLoader()));
}
}
@Override
public void close() {
// Closes any AutoCloseable objects stored in the context
namedObjects.values().stream().filter(v -> v instanceof AutoCloseable).forEach(o -> Util.close((AutoCloseable) o));
}
static <T> Function<T, String> className() {
return t -> t.getClass().getName();
}
}
| 2,105
| 35.947368
| 197
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/filesystem/Path.java
|
package org.infinispan.server.filesystem;
import java.io.File;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class Path {
private final String name;
private final File path;
public Path(String name, File path) {
this.name = name;
this.path = path;
}
public String getName() {
return name;
}
public File getPath() {
return path;
}
public String toString() {
return "Path{" +
"name='" + name + '\'' +
", path=" + path +
'}';
}
}
| 574
| 15.428571
| 57
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/loader/LogManager.java
|
package org.infinispan.server.loader;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.logging.Logger;
/**
* @since 14.0
**/
public class LogManager extends java.util.logging.LogManager {
private java.util.logging.LogManager delegate;
public LogManager() {
super();
}
public synchronized void setDelegate(java.util.logging.LogManager delegate) {
this.delegate = delegate;
super.reset();
}
@Override
public boolean addLogger(Logger logger) {
if (delegate != null) {
return delegate.addLogger(logger);
} else {
return super.addLogger(logger);
}
}
@Override
public Logger getLogger(String name) {
if (delegate != null) {
return delegate.getLogger(name);
} else {
return super.getLogger(name);
}
}
@Override
public Enumeration<String> getLoggerNames() {
if (delegate != null) {
return delegate.getLoggerNames();
} else {
return super.getLoggerNames();
}
}
@Override
public void readConfiguration() throws IOException, SecurityException {
if (delegate != null) {
delegate.readConfiguration();
} else {
super.readConfiguration();
}
}
@Override
public void reset() throws SecurityException {
if (delegate != null) {
delegate.reset();
} else {
super.reset();
}
}
@Override
public void readConfiguration(InputStream ins) throws IOException, SecurityException {
if (delegate != null) {
delegate.readConfiguration(ins);
} else {
super.readConfiguration(ins);
}
}
@Override
public void updateConfiguration(Function<String, BiFunction<String, String, String>> mapper) throws IOException {
if (delegate != null) {
delegate.updateConfiguration(mapper);
} else {
super.updateConfiguration(mapper);
}
}
@Override
public void updateConfiguration(InputStream ins, Function<String, BiFunction<String, String, String>> mapper) throws IOException {
if (delegate != null) {
delegate.updateConfiguration(ins, mapper);
} else {
super.updateConfiguration(ins, mapper);
}
}
@Override
public String getProperty(String name) {
if (delegate != null) {
return delegate.getProperty(name);
} else {
return super.getProperty(name);
}
}
@Override
public java.util.logging.LogManager addConfigurationListener(Runnable listener) {
if (delegate != null) {
return delegate.addConfigurationListener(listener);
} else {
return super.addConfigurationListener(listener);
}
}
@Override
public void removeConfigurationListener(Runnable listener) {
if (delegate != null) {
delegate.removeConfigurationListener(listener);
} else {
super.removeConfigurationListener(listener);
}
}
}
| 3,108
| 24.072581
| 133
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/loader/Loader.java
|
package org.infinispan.server.loader;
import java.io.File;
import java.io.IOException;
import java.io.Reader;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.FileVisitOption;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
/**
* Generic loader which constructs a classloader from all the jars found in some known locations and invokes the main
* method on a specified class. This allows us to avoid the construction of huge classpaths in the shell scripts that
* launch the server.
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class Loader {
/**
* Property name indicating the path to the server installation. If unspecified, the current working directory will
* be used
*/
public static final String INFINISPAN_SERVER_HOME_PATH = "infinispan.server.home.path";
/**
* Property name indicating the path to the root of a server instance. If unspecified, defaults to the <i>server</i>
* directory under the server home.
*/
public static final String INFINISPAN_SERVER_ROOT_PATH = "infinispan.server.root.path";
/**
* Property name indicating the paths to the server lib directories. If unspecified, defaults to the <i>lib</i>
* directory under the server root.
*/
public static final String INFINISPAN_SERVER_LIB_PATH = "infinispan.server.lib.path";
public static final String DEFAULT_SERVER_ROOT_DIR = "server";
public static void main(String[] args) {
run(args, System.getProperties());
}
public static void run(String[] args, Properties properties) {
if (args.length == 0) {
System.err.println("You must specify a classname to launch");
}
// Scan the arguments looking for -s, --server-root=, -P, --properties=
String root = null;
String propertyFile = null;
for (int i = 0; i < args.length; i++) {
if ("-s".equals(args[i]) && i < args.length - 1) {
root = args[i + 1];
break;
} else if (args[i].startsWith("--server-root=")) {
root = args[i].substring(args[i].indexOf('=') + 1);
break;
} else if ("-P".equals(args[i]) && i < args.length - 1) {
propertyFile = args[i + 1];
break;
} else if (args[i].startsWith("--properties=")) {
propertyFile = args[i].substring(args[i].indexOf('=') + 1);
break;
}
}
if (propertyFile != null) {
try (Reader r = Files.newBufferedReader(Paths.get(propertyFile))) {
Properties loaded = new Properties();
loaded.load(r);
loaded.forEach(properties::putIfAbsent);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
}
String home = properties.getProperty(INFINISPAN_SERVER_HOME_PATH, properties.getProperty("user.dir"));
ClassLoader bootClassLoader = Loader.class.getClassLoader();
ClassLoader serverClassLoader = classLoaderFromPath(Paths.get(home, "lib"), bootClassLoader);
if (root == null) {
root = properties.getProperty(INFINISPAN_SERVER_ROOT_PATH, Paths.get(home, DEFAULT_SERVER_ROOT_DIR).toString());
}
String lib = properties.getProperty(INFINISPAN_SERVER_LIB_PATH);
if (lib != null) {
for (String item : lib.split(File.pathSeparator)) {
serverClassLoader = classLoaderFromPath(Paths.get(item), serverClassLoader);
}
} else {
serverClassLoader = classLoaderFromPath(Paths.get(root, "lib"), serverClassLoader);
}
Thread.currentThread().setContextClassLoader(serverClassLoader);
try {
Class<?> mainClass = serverClassLoader.loadClass(args[0]);
Method mainMethod = mainClass.getMethod("main", String[].class);
String[] mainArgs = new String[args.length - 1];
System.arraycopy(args, 1, mainArgs, 0, mainArgs.length);
mainMethod.invoke(null, (Object) mainArgs);
} catch (Exception e) {
System.err.println(e.getMessage());
e.printStackTrace(System.err);
}
}
public static ClassLoader classLoaderFromPath(Path path, ClassLoader parent) {
try {
if (!Files.exists(path)) {
return parent;
}
Map<String, URL> urls = new LinkedHashMap<>();
Files.walkFileTree(path, Collections.singleton(FileVisitOption.FOLLOW_LINKS), Integer.MAX_VALUE, new FileVisitor<Path>() {
@Override
public FileVisitResult preVisitDirectory(Path p, BasicFileAttributes attrs) throws IOException {
urls.put(p.toString(), p.toUri().toURL());
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFile(Path p, BasicFileAttributes attrs) throws IOException {
if (p.toString().endsWith(".jar")) {
String artifact = extractArtifactName(p.getFileName().toString());
if (urls.containsKey(artifact)) {
throw new IllegalArgumentException("Duplicate JARs:\n" + p.toAbsolutePath().normalize() + "\n" + urls.get(artifact));
} else {
urls.put(artifact, p.toUri().toURL());
}
}
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFileFailed(Path p, IOException exc) throws IOException {
return FileVisitResult.SKIP_SUBTREE;
}
@Override
public FileVisitResult postVisitDirectory(Path p, IOException exc) throws IOException {
return FileVisitResult.CONTINUE;
}
});
final URL[] array = urls.values().toArray(new URL[urls.size()]);
if (parent == null)
return new URLClassLoader(array);
else
return new URLClassLoader(array, parent);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static String extractArtifactName(String filename) {
int l = filename.length();
for (int i = 0; i < l; i++) {
char c = filename.charAt(i);
if (c == '-' && i < l - 1) {
c = filename.charAt(i + 1);
if (c >= '0' && c <= '9') {
return filename.substring(0, i);
}
}
}
// Could not obtain an artifact
return filename;
}
}
| 6,855
| 38.177143
| 138
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/loader/ServerLoginModule.java
|
package org.infinispan.server.loader;
import java.util.Map;
import java.util.function.BiPredicate;
import javax.security.auth.Subject;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.spi.LoginModule;
/**
* @since 14.0
**/
public class ServerLoginModule implements LoginModule {
private Subject subject;
private CallbackHandler callbackHandler;
private static BiPredicate<CallbackHandler, Subject> AUTHENTICATOR;
public static void setAuthenticator(BiPredicate<CallbackHandler, Subject> authenticator) {
AUTHENTICATOR = authenticator;
}
@Override
public void initialize(Subject subject, CallbackHandler callbackHandler, Map<String, ?> sharedState, Map<String, ?> options) {
this.subject = subject;
this.callbackHandler = callbackHandler;
}
@Override
public boolean login() {
return (AUTHENTICATOR != null && AUTHENTICATOR.test(callbackHandler, subject));
}
@Override
public boolean commit() {
return true;
}
@Override
public boolean abort() {
return true;
}
@Override
public boolean logout() {
return true;
}
}
| 1,155
| 23.083333
| 129
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/tool/Main.java
|
package org.infinispan.server.tool;
import java.io.File;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Properties;
import org.infinispan.server.Server;
import org.infinispan.server.logging.Messages;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public abstract class Main {
protected final PrintStream stdOut;
protected final PrintStream stdErr;
protected final Properties properties;
protected final String cwd;
protected File serverHome;
protected File serverRoot;
public Main() {
this(System.out, System.err, System.getProperties());
}
public Main(PrintStream stdOut, PrintStream stdErr, Properties properties) {
this.stdOut = stdOut;
this.stdErr = stdErr;
this.properties = properties;
this.cwd = properties.getProperty("user.dir");
// Retrieve the server home from the properties if present, otherwise use the current working directory
serverHome = new File(properties.getProperty(Server.INFINISPAN_SERVER_HOME_PATH, cwd));
// Retrieve the server root from the properties if present, otherwise use the default server root under the server home
serverRoot = new File(properties.getProperty(Server.INFINISPAN_SERVER_ROOT_PATH, new File(serverHome, Server.DEFAULT_SERVER_ROOT_DIR).getAbsolutePath()));
}
public final void run(String... args) {
Iterator<String> iterator = Arrays.stream(args).iterator();
while (iterator.hasNext()) {
String command = iterator.next();
String parameter = null;
if (command.startsWith("--")) {
int equals = command.indexOf('=');
if (equals > 0) {
parameter = command.substring(equals + 1);
command = command.substring(0, equals);
}
} else if (command.startsWith("-D")) {
if (command.length() < 3) {
stdErr.println(Messages.MSG.invalidArgument(command));
exit(1);
return;
} else {
parameter = command.substring(2);
command = command.substring(0, 2);
}
} else if (command.startsWith("-")) {
if (command.length() != 2) {
stdErr.println(Messages.MSG.invalidShortArgument(command));
exit(1);
return;
}
} else {
stdErr.println(Messages.MSG.invalidArgument(command));
exit(1);
return;
}
switch (command) {
case "-h":
case "--help":
version(stdOut);
help(stdOut);
exit(0);
return;
case "-D":
int equals = parameter.indexOf('=');
properties.setProperty(parameter.substring(0, equals), parameter.substring(equals + 1));
break;
case "-v":
case "--version":
version(stdOut);
exit(0);
return;
default:
try {
handleArgumentCommand(command, parameter, iterator);
} catch (IllegalArgumentException e) {
stdErr.println(Messages.MSG.unknownArgument(command));
exit(1);
return;
}
break;
}
}
runInternal();
}
protected abstract void runInternal();
protected abstract void handleArgumentCommand(String command, String parameter, Iterator<String> args);
public void exit(int exitCode) {
System.exit(exitCode);
}
public abstract void help(PrintStream out);
public abstract void version(PrintStream out);
}
| 3,769
| 32.362832
| 160
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/datasource/DataSourceFactory.java
|
package org.infinispan.server.datasource;
import java.sql.SQLException;
import java.time.Duration;
import javax.sql.DataSource;
import org.infinispan.commons.util.ReflectionUtil;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.DataSourceConfiguration;
import io.agroal.api.AgroalDataSource;
import io.agroal.api.configuration.AgroalConnectionPoolConfiguration;
import io.agroal.api.configuration.supplier.AgroalConnectionFactoryConfigurationSupplier;
import io.agroal.api.configuration.supplier.AgroalConnectionPoolConfigurationSupplier;
import io.agroal.api.configuration.supplier.AgroalDataSourceConfigurationSupplier;
import io.agroal.api.exceptionsorter.DB2ExceptionSorter;
import io.agroal.api.exceptionsorter.MSSQLExceptionSorter;
import io.agroal.api.exceptionsorter.MySQLExceptionSorter;
import io.agroal.api.exceptionsorter.OracleExceptionSorter;
import io.agroal.api.exceptionsorter.PostgreSQLExceptionSorter;
import io.agroal.api.exceptionsorter.SybaseExceptionSorter;
import io.agroal.api.security.NamePrincipal;
import io.agroal.api.security.SimplePassword;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class DataSourceFactory {
public static DataSource create(DataSourceConfiguration configuration) throws SQLException, ClassNotFoundException {
AgroalConnectionFactoryConfigurationSupplier factory = new AgroalConnectionFactoryConfigurationSupplier();
String driver = configuration.driver();
Class<?> driverClass = ReflectionUtil.getClassForName(driver, Thread.currentThread().getContextClassLoader());
factory.connectionProviderClass(driverClass)
.jdbcTransactionIsolation(configuration.transactionIsolation())
.jdbcUrl(configuration.url())
.principal(new NamePrincipal(configuration.username()))
.credential(new SimplePassword(configuration.password()))
.initialSql(configuration.initialSql());
configuration.connectionProperties().forEach(factory::jdbcProperty);
AgroalConnectionPoolConfigurationSupplier pool = new AgroalConnectionPoolConfigurationSupplier();
pool.connectionFactoryConfiguration(factory)
.maxSize(configuration.maxSize())
.minSize(configuration.minSize())
.initialSize(configuration.initialSize())
.connectionValidator(AgroalConnectionPoolConfiguration.ConnectionValidator.defaultValidator())
.idleValidationTimeout(Duration.ofMillis(configuration.validateOnAcquisition()))
.acquisitionTimeout(Duration.ofMillis(configuration.blockingTimeout()))
.validationTimeout(Duration.ofMillis(configuration.backgroundValidation()))
.leakTimeout(Duration.ofMillis(configuration.leakDetection()))
.reapTimeout(Duration.ofMinutes(configuration.idleRemoval()));
if (driver.contains("postgresql")) {
pool.exceptionSorter(new PostgreSQLExceptionSorter());
} else if (driver.contains("mysql")|| driver.contains("mariadb")) {
pool.exceptionSorter(new MySQLExceptionSorter());
} else if (driver.contains("oracle")) {
pool.exceptionSorter(new OracleExceptionSorter());
} else if (driver.contains("sqlserver")) {
pool.exceptionSorter(new MSSQLExceptionSorter());
} else if (driver.contains("db2")) {
pool.exceptionSorter(new DB2ExceptionSorter());
} else if (driver.contains("sybase")) {
pool.exceptionSorter(new SybaseExceptionSorter());
}
AgroalDataSourceConfigurationSupplier cs = new AgroalDataSourceConfigurationSupplier();
cs.metricsEnabled(configuration.statistics())
.connectionPoolConfiguration(pool);
Server.log.dataSourceCreated(configuration.name(), configuration.jndiName());
return AgroalDataSource.from(cs);
}
}
| 3,875
| 48.692308
| 119
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/tasks/PersistenceContextInitializer.java
|
package org.infinispan.server.tasks;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
import org.infinispan.security.impl.SubjectAdapter;
import org.infinispan.tasks.TaskContext;
/**
* Interface used to initialise a {@link org.infinispan.protostream.SerializationContext} using the specified Pojos,
* Marshaller implementations and provided .proto schemas.
*
* @author Tristan Tarrant
* @since 11.0
*/
@AutoProtoSchemaBuilder(
includeClasses = {
SubjectAdapter.class,
TaskContext.class,
DistributedServerTask.class
},
schemaFileName = "persistence.servertasks.proto",
schemaFilePath = "proto/generated",
schemaPackageName = "org.infinispan.persistence.servertasks",
service = false
)
interface PersistenceContextInitializer extends SerializationContextInitializer {
}
| 936
| 32.464286
| 116
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/tasks/DistributedServerTask.java
|
package org.infinispan.server.tasks;
import java.util.function.Function;
import org.infinispan.Cache;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.marshall.ProtoStreamTypeIds;
import org.infinispan.commons.marshall.StreamingMarshaller;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.protostream.annotations.ProtoTypeId;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.tasks.TaskContext;
/**
* @author Michal Szynkiewicz, michal.l.szynkiewicz@gmail.com
*/
@ProtoTypeId(ProtoStreamTypeIds.DISTRIBUTED_SERVER_TASK)
public class DistributedServerTask<T> implements Function<EmbeddedCacheManager, T> {
@ProtoField(1)
final String taskName;
@ProtoField(2)
final String cacheName;
@ProtoField(3)
final TaskContext context;
@ProtoFactory
public DistributedServerTask(String taskName, String cacheName, TaskContext context) {
this.cacheName = cacheName;
this.taskName = taskName;
this.context = context;
}
@Override
public T apply(EmbeddedCacheManager embeddedCacheManager) {
Cache<Object, Object> cache = cacheName != null ? embeddedCacheManager.getCache(cacheName) : null;
// todo inject global component registry to be independent of existence of cache.
GlobalComponentRegistry componentRegistry = SecurityActions.getGlobalComponentRegistry(embeddedCacheManager);
ServerTaskEngine serverTaskEngine = componentRegistry.getComponent(ServerTaskEngine.class);
Marshaller marshaller = componentRegistry.getComponent(StreamingMarshaller.class);
ServerTaskWrapper<T> task = serverTaskEngine.getTask(taskName);
TaskContext ctx = prepareContext(embeddedCacheManager, cache, marshaller);
try {
return task.run(ctx);
} catch (Exception e) {
throw new CacheException(e);
}
}
private TaskContext prepareContext(EmbeddedCacheManager embeddedCacheManager, Cache<Object, Object> cache, Marshaller marshaller) {
TaskContext context = new TaskContext(this.context);
context.cacheManager(embeddedCacheManager);
MediaType type = MediaType.APPLICATION_OBJECT;
if (cache != null) context.cache(cache.getAdvancedCache().withMediaType(type, type));
if (marshaller != null) context.marshaller(marshaller);
return context;
}
}
| 2,649
| 39.769231
| 134
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/tasks/ServerTaskEngine.java
|
package org.infinispan.server.tasks;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_OBJECT;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.marshall.core.EncoderRegistry;
import org.infinispan.marshall.protostream.impl.SerializationContextRegistry;
import org.infinispan.scripting.utils.ScriptConversions;
import org.infinispan.security.AuthorizationManager;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.security.impl.Authorizer;
import org.infinispan.tasks.Task;
import org.infinispan.tasks.TaskContext;
import org.infinispan.tasks.TaskExecutionMode;
import org.infinispan.tasks.spi.TaskEngine;
import org.infinispan.util.concurrent.BlockingManager;
/**
* @author Michal Szynkiewicz, michal.l.szynkiewicz@gmail.com
*/
public class ServerTaskEngine implements TaskEngine {
private final LocalServerTaskRunner localRunner;
private final DistributedServerTaskRunner distributedRunner;
private final Authorizer globalauthorizer;
private final ScriptConversions scriptConversions;
private final Map<String, ServerTaskWrapper> tasks;
public ServerTaskEngine(EmbeddedCacheManager cacheManager, Map<String, ServerTaskWrapper> tasks) {
GlobalComponentRegistry registry = SecurityActions.getGlobalComponentRegistry(cacheManager);
registry.registerComponent(this, ServerTaskEngine.class);
SerializationContextRegistry serializationContextRegistry = registry.getComponent(SerializationContextRegistry.class);
serializationContextRegistry.addContextInitializer(SerializationContextRegistry.MarshallerType.PERSISTENCE, new PersistenceContextInitializerImpl());
EncoderRegistry encoderRegistry = registry.getComponent(EncoderRegistry.class);
this.scriptConversions = new ScriptConversions(encoderRegistry);
this.globalauthorizer = registry.getComponent(Authorizer.class);
this.tasks = tasks;
this.localRunner = new LocalServerTaskRunner(this);
this.distributedRunner = new DistributedServerTaskRunner();
}
@Override
public String getName() {
return "Deployed";
}
@Override
public List<Task> getTasks() {
return new ArrayList<>(tasks.values());
}
@Override
public <T> CompletableFuture<T> runTask(String taskName, TaskContext context, BlockingManager blockingManager) {
ServerTaskWrapper<T> task = tasks.get(taskName);
if (task == null) {
throw new IllegalArgumentException("Task not found: " + taskName);
}
checkPermissions(context, task);
return invokeTask(context, task);
}
private <T> CompletableFuture<T> invokeTask(TaskContext context, ServerTaskWrapper<T> task) {
ServerTaskRunner runner;
if (task.getExecutionMode() == TaskExecutionMode.ONE_NODE) {
runner = localRunner;
} else {
runner = distributedRunner;
}
launderParameters(context);
MediaType requestMediaType = context.getCache().map(c -> c.getAdvancedCache().getValueDataConversion().getRequestMediaType()).orElse(MediaType.MATCH_ALL);
context.getCache().ifPresent(c -> context.cache(c.getAdvancedCache().withMediaType(APPLICATION_OBJECT, APPLICATION_OBJECT)));
return runner.execute(task.getName(), context).thenApply(r -> (T) scriptConversions.convertToRequestType(r, APPLICATION_OBJECT, requestMediaType));
}
private void launderParameters(TaskContext context) {
if (context.getParameters().isPresent()) {
Map<String, Object> convertParameters = scriptConversions.convertParameters(context);
context.parameters(convertParameters);
}
}
private <T> void checkPermissions(TaskContext context, ServerTaskWrapper<T> task) {
String role = task.getRole().orElse(null);
if (globalauthorizer != null) {
if (context.getCache().isPresent()) {
AuthorizationManager authorizationManager = SecurityActions.getCacheAuthorizationManager(context.getCache().get().getAdvancedCache());
if (authorizationManager != null) {
// when the cache is secured
authorizationManager.checkPermission(AuthorizationPermission.EXEC, role);
return;
}
}
if (context.getSubject().isPresent()) {
// if the subject is present, then use the subject
globalauthorizer.checkPermission(context.getSubject().get(), AuthorizationPermission.EXEC);
return;
}
globalauthorizer.checkPermission(null, null, AuthorizationPermission.EXEC, role);
}
}
@Override
public boolean handles(String taskName) {
return tasks.containsKey(taskName);
}
public <T> ServerTaskWrapper<T> getTask(String taskName) {
return tasks.get(taskName);
}
}
| 5,102
| 41.882353
| 160
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/tasks/LocalServerTaskRunner.java
|
package org.infinispan.server.tasks;
import java.util.concurrent.CompletableFuture;
import org.infinispan.security.Security;
import org.infinispan.tasks.TaskContext;
/**
* @author Michal Szynkiewicz, michal.l.szynkiewicz@gmail.com
*/
public class LocalServerTaskRunner implements ServerTaskRunner {
private final ServerTaskEngine serverTaskEngine;
public LocalServerTaskRunner(ServerTaskEngine serverTaskEngine) {
this.serverTaskEngine = serverTaskEngine;
}
@Override
public <T> CompletableFuture<T> execute(String taskName, TaskContext context) {
ServerTaskWrapper<T> task = serverTaskEngine.getTask(taskName);
try {
return CompletableFuture.completedFuture(Security.doAs(context.subject(), task, context));
} catch (Exception e) {
CompletableFuture<T> finishedWithException = new CompletableFuture<>();
finishedWithException.completeExceptionally(e);
return finishedWithException;
}
}
}
| 981
| 30.677419
| 99
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.