Java BasicAuthenticationEntryPoint类代码示例

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, final FilterChain servletChain)
        throws IOException, ServletException {
    FilterChain chainWithAdditive = (request, response) -> {
        try {
            AddonsManager addonsManager = ContextHelper.get().beanForType(AddonsManager.class);
            addonsManager.addonByType(PluginsWebAddon.class).executeAdditiveRealmPlugins();
            servletChain.doFilter(request, response);
        } catch (AuthenticationException e) {
            ContextHelper.get().beanForType(BasicAuthenticationEntryPoint.class).commence(
                    (HttpServletRequest) request, (HttpServletResponse) response, e);
        }
    };

    // First one that accepts
    for (ArtifactoryAuthenticationFilter filter : this.authenticationFilters) {
        if (filter.acceptFilter(servletRequest)) {
            filter.doFilter(servletRequest, servletResponse, chainWithAdditive);
            // TODO: May be check that the response was done
            return;
        }
    }
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Override
protected void configure(HttpSecurity http) throws Exception {

	final BasicAuthenticationEntryPoint basicAuthenticationEntryPoint = new BasicAuthenticationEntryPoint();
	basicAuthenticationEntryPoint.setRealmName(securityProperties.getBasic().getRealm());
	basicAuthenticationEntryPoint.afterPropertiesSet();
	final Filter oauthFilter = oauthFilter();
	final BasicAuthenticationFilter basicAuthenticationFilter = new BasicAuthenticationFilter(
			providerManager(), basicAuthenticationEntryPoint);
	http.addFilterAfter(oauthFilter, basicAuthenticationFilter.getClass());
	http.addFilterBefore(basicAuthenticationFilter, oauthFilter.getClass());
	http.addFilterBefore(oAuth2AuthenticationProcessingFilter(), basicAuthenticationFilter.getClass());
	this.authorizationProperties.getAuthenticatedPaths().add(dashboard("/**"));
	this.authorizationProperties.getAuthenticatedPaths().add(dashboard(""));

	ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry security =
		http.authorizeRequests()
				.antMatchers(this.authorizationProperties.getPermitAllPaths().toArray(new String[0]))
				.permitAll()
				.antMatchers(this.authorizationProperties.getAuthenticatedPaths().toArray(new String[0]))
				.authenticated();

	security = SecurityConfigUtils.configureSimpleSecurity(security, this.authorizationProperties);
	security.anyRequest().denyAll();
	this.securityStateBean.setAuthorizationEnabled(true);

	http.httpBasic().and()
			.logout()
			.logoutSuccessUrl(dashboard("/logout-success-oauth.html"))
			.and().csrf().disable()
			.exceptionHandling()
			.defaultAuthenticationEntryPointFor(basicAuthenticationEntryPoint, new AntPathRequestMatcher("/api/**"))
			.defaultAuthenticationEntryPointFor(basicAuthenticationEntryPoint, new AntPathRequestMatcher("/actuator/**"))
			.defaultAuthenticationEntryPointFor(
					new LoginUrlAuthenticationEntryPoint(this.authorizationProperties.getLoginProcessingUrl()),
					AnyRequestMatcher.INSTANCE);
	this.securityStateBean.setAuthenticationEnabled(true);
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Override
    public void configure(HttpSecurity http) throws Exception {
        http
                .headers()
                    .cacheControl().disable()
                .and()
                .csrf().disable()
                .authorizeRequests()
                .antMatchers(HttpMethod.GET).permitAll()
                .antMatchers("/api/users").permitAll()
//                .antMatchers("/**").permitAll().and()
                .anyRequest().authenticated()
                .and()
                .exceptionHandling().authenticationEntryPoint(new BasicAuthenticationEntryPoint() {
            @Override
            public void commence(final HttpServletRequest request, final HttpServletResponse response, final AuthenticationException authException) throws IOException, ServletException {
                if (HttpMethod.OPTIONS.matches(request.getMethod())) {
                    response.setStatus(HttpServletResponse.SC_OK);
                    response.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, request.getHeader(HttpHeaders.ORIGIN));
                    response.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, request.getHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS));
                    response.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, request.getHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD));
                    response.setHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS, "true");
                } else {
                    response.sendError(HttpServletResponse.SC_UNAUTHORIZED, authException.getMessage());
                }
            }
        });
    }
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Override
protected void configure(final HttpSecurity http) throws Exception {

    final BasicAuthenticationEntryPoint basicAuthEntryPoint = new BasicAuthenticationEntryPoint();
    basicAuthEntryPoint.setRealmName(springSecurityProperties.getBasic().getRealm());

    HttpSecurity httpSec = http.regexMatcher("\\/rest.*|\\/system/admin.*").csrf().disable();
    if (springSecurityProperties.isRequireSsl()) {
        httpSec = httpSec.requiresChannel().anyRequest().requiresSecure().and();
    }

    httpSec.addFilterBefore(new Filter() {
        @Override
        public void init(final FilterConfig filterConfig) throws ServletException {
            userAuthenticationFilter.init(filterConfig);
        }

        @Override
        public void doFilter(final ServletRequest request, final ServletResponse response,
                final FilterChain chain) throws IOException, ServletException {
            userAuthenticationFilter.doFilter(request, response, chain);
        }

        @Override
        public void destroy() {
            userAuthenticationFilter.destroy();
        }
    }, RequestHeaderAuthenticationFilter.class)
            .addFilterAfter(new AuthenticationSuccessTenantMetadataCreationFilter(systemManagement,
                    systemSecurityContext), SessionManagementFilter.class)
            .authorizeRequests().anyRequest().authenticated()
            .antMatchers(MgmtRestConstants.BASE_SYSTEM_MAPPING + "/admin/**")
            .hasAnyAuthority(SpPermission.SYSTEM_ADMIN);

    httpSec.httpBasic().and().exceptionHandling().authenticationEntryPoint(basicAuthEntryPoint);
    httpSec.anonymous().disable();
    httpSec.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
/**
 * send Challenge Message To Anonymous If List Node is empty due to Missing Permission
 *
 * @param repoPath              - repo path
 * @param rootNodesFilterResult - object hold empty list canRead flag
 * @param items                 - list of Items
 * @throws IOException
 */
private void sendChallengeMessage(RepoPath repoPath,
                                  RootNodesFilterResult rootNodesFilterResult,
                                  List<? extends BaseBrowsableItem> items,
                                  HttpServletResponse response) throws IOException {
    ContextHelper.get().beanForType(BasicAuthenticationEntryPoint.class);
    if (isItemListEmptyDueAnonymousMissingPermission(rootNodesFilterResult, items)) {
        ArtifactoryResponse artifactoryResponse = new HttpArtifactoryResponse(response);
        artifactoryResponse.sendAuthorizationRequired("Browse request for repo:path " + repoPath + " is forbidden " +
                "for user 'anonymous'.", REALM);
    }
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Override
public void init(FilterConfig filterConfig) throws ServletException {
    ServletContext servletContext = filterConfig.getServletContext();
    ArtifactoryContext context = RequestUtils.getArtifactoryContext(servletContext);
    springBasicAuthenticationFilter = context.beanForType(BasicAuthenticationFilter.class);
    authenticationEntryPoint = context.beanForType(BasicAuthenticationEntryPoint.class);
    springBasicAuthenticationFilter.init(filterConfig);
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
/**
 * send Challenge Message To Anonymous If List Node is empty due to Missing Permission
 * @param repoPath - repo path
 * @param rootNodesFilterResult - object hold empty list canRead flag
 * @param items - list of Items
 * @throws IOException
 */
private void sendChallengeMessageIfListNodeIsEmptyDueToAnonymousPermissionIssue(RepoPath repoPath,
        RootNodesFilterResult rootNodesFilterResult, List<? extends BaseBrowsableItem> items)
        throws IOException {
        ArtifactoryBasicAuthenticationEntryPoint authenticationEntryPoint=(ArtifactoryBasicAuthenticationEntryPoint)
                ContextHelper.get().beanForType(BasicAuthenticationEntryPoint.class);
    if (isItemListEmptyDueAnonymousMissingPermission(rootNodesFilterResult, items)){
        HttpServletResponse servletResponse = WicketUtils.getHttpServletResponse();
        ArtifactoryResponse artifactoryResponse = new HttpArtifactoryResponse(servletResponse);
        artifactoryResponse.sendAuthorizationRequired("Browse request for repo:path " +repoPath+" is forbidden " +
                "for user 'anonymous'.",authenticationEntryPoint.getRealmName());
     }
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Bean
public BasicAuthenticationEntryPoint basicAuthenticationEntryPoint() {

    IRISBasicAuthEntryPoint authEntryPoint = new IRISBasicAuthEntryPoint();
    authEntryPoint.setRealmName("IRIS API");

    return authEntryPoint;
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Bean
@Autowired
public DelegatingAuthenticationEntryPoint delegatingAuthenticationEntryPoint(BasicAuthenticationEntryPoint basic,
    LoginUrlAuthenticationEntryPoint login) {

    LinkedHashMap<RequestMatcher, AuthenticationEntryPoint> entryPoints = new LinkedHashMap<>();
    entryPoints.put(new RequestHeaderRequestMatcher("Content-Type", "application/json"), basic);
    entryPoints.put(new NegatedRequestMatcher(new RequestContainingAcceptTextHeaderRequestMatcher()), basic);

    DelegatingAuthenticationEntryPoint delegate = new DelegatingAuthenticationEntryPoint(entryPoints);
    delegate.setDefaultEntryPoint(login);

    return delegate;
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Bean
public BasicAuthenticationEntryPoint entryPoint ()
{

  BasicAuthenticationEntryPoint basicAuthenticationEntryPoint = new BasicAuthenticationEntryPoint();
  basicAuthenticationEntryPoint.setRealmName("Basic WF Realm");
  
  return basicAuthenticationEntryPoint;
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Bean
BasicAuthenticationFilter basicAuthFilter(AuthenticationManager authenticationManager,
		BasicAuthenticationEntryPoint basicAuthEntryPoint) {
	return new BasicAuthenticationFilter(authenticationManager, basicAuthEntryPoint());
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Bean
BasicAuthenticationEntryPoint basicAuthEntryPoint() {
	BasicAuthenticationEntryPoint bauth = new BasicAuthenticationEntryPoint();
	bauth.setRealmName("GAURAVBYTES");
	return bauth;
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
@Override
protected void configure(HttpSecurity http) throws Exception {
	final RequestMatcher textHtmlMatcher = new MediaTypeRequestMatcher(
			contentNegotiationStrategy,
			MediaType.TEXT_HTML);

	final String loginPage = dashboard("/#/login");

	final BasicAuthenticationEntryPoint basicAuthenticationEntryPoint = new BasicAuthenticationEntryPoint();
	basicAuthenticationEntryPoint.setRealmName(securityProperties.getBasic().getRealm());
	basicAuthenticationEntryPoint.afterPropertiesSet();

	http
		.csrf()
		.disable()
		.authorizeRequests()
		.antMatchers("/")
		.authenticated()
		.antMatchers(
				dashboard("/**"),
				"/authenticate",
				"/security/info",
				"/features",
				"/assets/**").permitAll()
	.and()
		.formLogin().loginPage(loginPage)
		.loginProcessingUrl(dashboard("/login"))
		.defaultSuccessUrl(dashboard("/")).permitAll()
	.and()
		.logout().logoutUrl(dashboard("/logout"))
			.logoutSuccessUrl(dashboard("/logout-success.html"))
		.logoutSuccessHandler(new HttpStatusReturningLogoutSuccessHandler()).permitAll()
	.and().httpBasic()
		.and().exceptionHandling()
		.defaultAuthenticationEntryPointFor(
				new LoginUrlAuthenticationEntryPoint(loginPage),
				textHtmlMatcher)
		.defaultAuthenticationEntryPointFor(basicAuthenticationEntryPoint,
				AnyRequestMatcher.INSTANCE)
	.and()
		.authorizeRequests()
		.anyRequest().authenticated();

	final SessionRepositoryFilter<ExpiringSession> sessionRepositoryFilter = new SessionRepositoryFilter<ExpiringSession>(
			sessionRepository());
	sessionRepositoryFilter
			.setHttpSessionStrategy(new HeaderHttpSessionStrategy());

	http.addFilterBefore(sessionRepositoryFilter,
			ChannelProcessingFilter.class).csrf().disable();
	http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED);
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
public void setBasicAuthenticationEntryPoint(
		BasicAuthenticationEntryPoint basicAuthenticationEntryPoint) {
	this.basicAuthenticationEntryPoint = basicAuthenticationEntryPoint;
}
 

import org.springframework.security.web.authentication.www.BasicAuthenticationEntryPoint; //导入依赖的package包/类
public BasicAuthenticationEntryPoint getAuthenticationEntryPoint() {
    BasicAuthenticationEntryPoint basicAuthenticationEntryPoint = new BasicAuthenticationEntryPoint();
    basicAuthenticationEntryPoint.setRealmName("atlas.com");
    return basicAuthenticationEntryPoint;
}