Refine search
l.setName(realm); Constraint constraint = new Constraint(); constraint.setName(Constraint.__BASIC_AUTH); constraint.setRoles(new String[]{"user"}); constraint.setAuthenticate(true); Constraint noConstraint = new Constraint(); ConstraintMapping healthcheckConstraintMapping = new ConstraintMapping(); healthcheckConstraintMapping.setConstraint(noConstraint); healthcheckConstraintMapping.setPathSpec("/api/v1/health/check"); ConstraintMapping cm = new ConstraintMapping(); cm.setConstraint(constraint); cm.setPathSpec("/*"); ConstraintSecurityHandler csh = new ConstraintSecurityHandler(); csh.setAuthenticator(new BasicAuthenticator()); csh.setRealmName("myrealm"); csh.addConstraintMapping(healthcheckConstraintMapping); csh.addConstraintMapping(cm);
Constraint scBase = new Constraint(); scBase.setAuthenticate(true); roles.add(role); scBase.setRoles(roles.toArray(new String[roles.size()])); ConstraintMapping mapping = new ConstraintMapping(); mapping.setMethod(method); mapping.setPathSpec(url); mapping.setConstraint(sc); ((ConstraintAware)context.getSecurityHandler()).addConstraintMapping(mapping); ConstraintMapping mapping = new ConstraintMapping(); mapping.setMethodOmissions(new String[]{method}); mapping.setPathSpec(url); mapping.setConstraint(sc); ((ConstraintAware)context.getSecurityHandler()).addConstraintMapping(mapping); ConstraintMapping mapping = new ConstraintMapping(); mapping.setPathSpec(url); mapping.setConstraint(sc); ((ConstraintAware)context.getSecurityHandler()).addConstraintMapping(mapping);
/** * @see org.eclipse.jetty.security.ConstraintAware#addConstraintMapping(org.eclipse.jetty.security.ConstraintMapping) */ @Override public void addConstraintMapping(ConstraintMapping mapping) { _constraintMappings.add(mapping); if (mapping.getConstraint()!=null && mapping.getConstraint().getRoles()!=null) { //allow for lazy role naming: if a role is named in a security constraint, try and //add it to the list of declared roles (ie as if it was declared with a security-role for (String role : mapping.getConstraint().getRoles()) { if ("*".equals(role) || "**".equals(role)) continue; addRole(role); } } if (isStarted()) { processConstraintMapping(mapping); } }
/** * Generate constraints for the Flume HTTP Source * @return ConstraintSecurityHandler for use with Jetty servlet */ public static ConstraintSecurityHandler enforceConstraints() { Constraint c = new Constraint(); c.setAuthenticate(true); ConstraintMapping cmt = new ConstraintMapping(); cmt.setConstraint(c); cmt.setMethod("TRACE"); cmt.setPathSpec("/*"); ConstraintMapping cmo = new ConstraintMapping(); cmo.setConstraint(c); cmo.setMethod("OPTIONS"); cmo.setPathSpec("/*"); ConstraintSecurityHandler sh = new ConstraintSecurityHandler(); sh.setConstraintMappings(new ConstraintMapping[]{cmt, cmo}); return sh; } }
protected void configureTraceMethod(ConstraintSecurityHandler securityHandler, boolean enableTrace) { Constraint constraint = new Constraint(); constraint.setName("trace-security"); //If enableTrace is true, then we want to set authenticate to false to allow it constraint.setAuthenticate(!enableTrace); ConstraintMapping mapping = new ConstraintMapping(); mapping.setConstraint(constraint); mapping.setMethod("TRACE"); mapping.setPathSpec("/"); securityHandler.addConstraintMapping(mapping); }
securityElement.getTransportGuarantee() != TransportGuarantee.NONE) httpConstraint = ConstraintSecurityHandler.createConstraint(name, securityElement); httpConstraintMapping = new ConstraintMapping(); httpConstraintMapping.setPathSpec(pathSpec); httpConstraintMapping.setConstraint(httpConstraint); mappings.add(httpConstraintMapping); Constraint methodConstraint = ConstraintSecurityHandler.createConstraint(name, methodConstraintElement); ConstraintMapping mapping = new ConstraintMapping(); mapping.setConstraint(methodConstraint); mapping.setPathSpec(pathSpec); if (methodConstraintElement.getMethodName() != null) mapping.setMethod(methodConstraintElement.getMethodName()); httpConstraintMapping.setMethodOmissions(methodOmissions.toArray(new String[methodOmissions.size()]));
static ConstraintSecurityHandler createSecurityHandler(String realm, List<String> roles) { final ConstraintSecurityHandler securityHandler = new ConstraintSecurityHandler(); Constraint constraint = new Constraint(); constraint.setAuthenticate(true); constraint.setRoles(roles.toArray(new String[0])); ConstraintMapping constraintMapping = new ConstraintMapping(); constraintMapping.setConstraint(constraint); constraintMapping.setMethod("*"); constraintMapping.setPathSpec("/*"); securityHandler.addConstraintMapping(constraintMapping); securityHandler.setAuthenticator(new BasicAuthenticator()); securityHandler.setLoginService(new JAASLoginService(realm)); securityHandler.setIdentityService(new DefaultIdentityService()); securityHandler.setRealmName(realm); return securityHandler; }
final ConstraintSecurityHandler securityHandler = new ConstraintSecurityHandler(); contextHandler.insertHandler(securityHandler); final Constraint constraint = new Constraint(); constraint.setName("auth"); constraint.setAuthenticate(true); constraint.setRoles(roles.split(",")); final ConstraintMapping constraintMapping = new ConstraintMapping(); constraintMapping.setPathSpec(context.getProperty(AUTH_PATH_SPEC).evaluateAttributeExpressions().getValue()); constraintMapping.setConstraint(constraint); securityHandler.setAuthenticatorFactory(authenticatorFactory); securityHandler.setAuthMethod(Constraint.__BASIC_AUTH); securityHandler.setRealmName(getClass().getSimpleName()); securityHandler.setConstraintMappings(Collections.singletonList(constraintMapping));
ConstraintSecurityHandler securityHandler = new ConstraintSecurityHandler(); if(auth) LoklakServer.server.addBean(loginService); Constraint constraint = new Constraint(); if(redirect) constraint.setDataConstraint(Constraint.DC_CONFIDENTIAL); if(auth){ constraint.setAuthenticate(true); constraint.setRoles(new String[] { "user", "admin" }); ConstraintMapping mapping = new ConstraintMapping(); mapping.setPathSpec( "/*" ); mapping.setConstraint(constraint); securityHandler.addConstraintMapping(mapping); securityHandler.setAuthenticator(new BasicAuthenticator()); securityHandler.setLoginService(loginService);
private ConstraintMapping[] getConstraintMappings(String ... pRoles) { Constraint constraint = new Constraint(); constraint.setName(Constraint.__BASIC_AUTH); constraint.setRoles(pRoles); constraint.setAuthenticate(true); ConstraintMapping cm = new ConstraintMapping(); cm.setConstraint(constraint); cm.setPathSpec("/*"); return new ConstraintMapping[] { cm }; }
public static void addPathConstraint(ConstraintSecurityHandler securityHandler, String pathSpec, String role) { Objects.requireNonNull(securityHandler); Objects.requireNonNull(pathSpec); ConstraintMapping mapping = new ConstraintMapping(); Constraint constraint = new Constraint(); String[] roles = new String[]{role}; constraint.setRoles(roles); constraint.setName(securityHandler.getAuthenticator().getAuthMethod()); constraint.setAuthenticate(true); mapping.setConstraint(constraint); mapping.setPathSpec(pathSpec); securityHandler.addConstraintMapping(mapping); }
private void auth(ServletContextHandler ctx, Authenticator authType) { final String role = "can-access"; MappedLoginService users = new MappedLoginService() { @Override protected UserIdentity loadUser(String who) { return null; } @Override protected void loadUsers() throws IOException { putUser(username, new Password(password), new String[] { role }); } }; ConstraintMapping cm = new ConstraintMapping(); cm.setConstraint(new Constraint()); cm.getConstraint().setAuthenticate(true); cm.getConstraint().setDataConstraint(Constraint.DC_NONE); cm.getConstraint().setRoles(new String[] { role }); cm.setPathSpec("/*"); ConstraintSecurityHandler sec = new ConstraintSecurityHandler(); sec.setStrict(false); sec.setRealmName(realm); sec.setAuthenticator(authType); sec.setLoginService(users); sec.setConstraintMappings(new ConstraintMapping[] { cm }); sec.setHandler(ctx); contexts.removeHandler(ctx); contexts.addHandler(sec); }
@Override public ConstraintMapping buildConstraintMapping() { ConstraintMapping csMapping = null; ConstraintInfo constraintInfo = myRef.metaInfo( ConstraintInfo.class ); if ( constraintInfo != null && constraintInfo.getConstraint() != null ) { Constraint constraint = new Constraint(); csMapping = new ConstraintMapping(); csMapping.setConstraint( constraint ); csMapping.setPathSpec( constraintInfo.getPath() ); if ( constraintInfo.getOmittedHttpMethods() != null && constraintInfo.getOmittedHttpMethods().length > 0 ) { csMapping.setMethodOmissions( HttpMethod.toStringArray( constraintInfo.getOmittedHttpMethods() ) ); } } return csMapping; }
private ConstraintMapping createConstraintMapping() { ConstraintMapping cm = new ConstraintMapping(); cm.setConstraint(new Constraint()); cm.getConstraint().setAuthenticate(true); cm.getConstraint().setDataConstraint(Constraint.DC_NONE); cm.getConstraint().setRoles(new String[] { authRole }); cm.setPathSpec("/*"); return cm; }
private void auth(ServletContextHandler ctx, Authenticator authType, String... methods) { AbstractLoginService users = new TestMappedLoginService(authRole); List<ConstraintMapping> mappings = new ArrayList<>(); if (methods == null || methods.length == 0) { mappings.add(createConstraintMapping()); } else { for (String method : methods) { ConstraintMapping cm = createConstraintMapping(); cm.setMethod(method.toUpperCase(Locale.ROOT)); mappings.add(cm); } } ConstraintSecurityHandler sec = new ConstraintSecurityHandler(); sec.setRealmName(realm); sec.setAuthenticator(authType); sec.setLoginService(users); sec.setConstraintMappings( mappings.toArray(new ConstraintMapping[0])); sec.setHandler(ctx); contexts.removeHandler(ctx); contexts.addHandler(sec); }
Constraint constraint = mapping.getConstraint(); boolean forbidden = constraint.isForbidden(); ri.setForbidden(forbidden); UserDataConstraint userDataConstraint = UserDataConstraint.get(mapping.getConstraint().getDataConstraint()); ri.setUserDataConstraint(userDataConstraint); boolean checked = mapping.getConstraint().getAuthenticate(); ri.setChecked(checked); if (mapping.getConstraint().isAnyRole()) ri.setAnyRole(true); else if (mapping.getConstraint().isAnyAuth()) String[] newRoles = mapping.getConstraint().getRoles(); for (String role : newRoles)
for (ConstraintMapping cm : constraintMappings) String[] cmr = cm.getConstraint().getRoles(); if (cmr!=null) setRoles(roles); if (isStarted()) processConstraintMapping(mapping);
String dynamicPattern = ...; ConstraintMapping mapping = new ConstraintMapping(); mapping.type( ContactInfo.class ) .property( "workPhone", FIELD ) .constraint( new PatternDef().regexp( dynamicPattern ) ); HibernateValidatorConfiguration config = Validation.byProvider( HibernateValidator.class ).configure(); config.addMapping( mapping ); Validator validator = config.buildValidatorFactory().getValidator();
protected void processConstraintMapping(ConstraintMapping mapping) { String pathSpec = mapping.getPathSpec(); StringTokenizer tok = new StringTokenizer(pathSpec, PATH_SPEC_SEPARATORS); String httpMethod = mapping.getMethod(); while (tok.hasMoreTokens()) { String spec = tok.nextToken().trim(); if (httpMethod == null) { if ("*".equals(spec)) { if (defaultRoleInfo == null) { defaultRoleInfo = new RoleInfo(); } addConstraint(defaultRoleInfo, mapping.getConstraint()); } else { throw new IllegalArgumentException("No method specified for PathSpec " + pathSpec + "."); } } RestPathMap<RoleInfo> mappings = constraintMap.get(httpMethod); if (mappings == null) { mappings = new RestPathMap<RoleInfo>(); constraintMap.put(httpMethod, mappings); } RoleInfo roleInfo = mappings.get(spec); if (roleInfo == null) { roleInfo = new RoleInfo(); mappings.put(spec, roleInfo); } addConstraint(roleInfo, mapping.getConstraint()); } }
/** * @see org.eclipse.jetty.security.ConstraintAware#addConstraintMapping(org.eclipse.jetty.security.ConstraintMapping) */ public void addConstraintMapping(ConstraintMapping mapping) { constraintMappings.add(mapping); if (mapping.getConstraint() != null && mapping.getConstraint().getRoles() != null) for (String role : mapping.getConstraint().getRoles()) if (!"*".equals(role)) addRole(role); if (isStarted()) { processConstraintMapping(mapping); } }