Acegi Captcha způsob integrace a možnosti použití

/**
 * Filter for web integration of the {@link org.acegisecurity.captcha.CaptchaServiceProxy}. 
 * It basically intercept calls containing the specific validation parameter, use the {@link org.acegisecurity.captcha.CaptchaServiceProxy} to
 * validate the request, and update the {@link org.acegisecurity.captcha.CaptchaSecurityContext} if the request passed the validation. 
 * This Filter should be placed after the ContextIntegration filter and before the {@link
 * org.acegisecurity.captcha.CaptchaChannelProcessorTemplate} filter in the filter stack in order to update the {@link org.acegisecurity.captcha.CaptchaSecurityContext}
 * before the humanity verification routine occurs. 
 * This filter should only be used in conjunction with the {@link org.acegisecurity.captcha.CaptchaSecurityContext}
 *

 * Filter extends the original one with adding functionality to return binary image when url end with
 * particular string.
 */
public class CaptchaGenerationValidationProcessingFilter implements InitializingBean, Filter, ApplicationEventPublisherAware {
	private static Log log = LogFactory.getLog(CaptchaGenerationValidationProcessingFilter.class);
	private CaptchaServiceProxy captchaService;
	private String captchaImgUrl = "generatedCaptchaImage.jpg";
	private String captchaValidationParameter = "captcha";
	private CaptchaService jcaptchaService;
	private ApplicationEventPublisher publisher;
	public static final String REQUEST_CAPTCHA_RECOGNITION_FAILURE_FLAG = "_acegi_captcha_recognition_failure_flag";
	public String getCaptchaImgUrl() {
		return captchaImgUrl;
	}
	public void setCaptchaImgUrl(String captchaImgUrl) {
		this.captchaImgUrl = captchaImgUrl;
	}
	public void setCaptchaValidationParameter(String captchaValidationParameter) {
		this.captchaValidationParameter = captchaValidationParameter;
	}
	public String getCaptchaValidationParameter() {
		return captchaValidationParameter;
	}
	public void setCaptchaService(CaptchaServiceProxy captchaService) {
		this.captchaService = captchaService;
	}
	public void setCaptchaServiceProvider(CaptchaServiceProvider captchaServiceProvider) {
		this.jcaptchaService = captchaServiceProvider.getCaptchaService();
	}
	//~ Methods ========================================================================================================
	public void afterPropertiesSet() throws Exception {
		if(this.captchaService == null) {
			throw new IllegalArgumentException("CaptchaServiceProxy must be defined ");
		}
		if((this.captchaValidationParameter == null) || "".equals(captchaValidationParameter)) {
			throw new IllegalArgumentException("captchaValidationParameter must not be empty or null");
		}
	}
	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
		this.publisher = applicationEventPublisher;
	}
	public void init(FilterConfig filterConfig) throws ServletException {
		//no implementation - we do everything in Spring lifecycle
	}
	public void destroy() {
		//no implementation - we do everything in Spring lifecycle
	}
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
		if((servletRequest != null) && servletRequest instanceof HttpServletRequest) {
			HttpServletRequest request = ((HttpServletRequest)servletRequest);
			HttpServletResponse response = ((HttpServletResponse)servletResponse);
			if(((HttpServletRequest)servletRequest).getRequestURI().endsWith(captchaImgUrl)) {
				generateImageOutputAndSkipProcessing(request, response);
			}
			else {
				String captchaResponse = request.getParameter(captchaValidationParameter);
				boolean continueWithChainProcessing = true;
				if(captchaResponse != null) {
					continueWithChainProcessing =
							validateCaptchaResponse(request, response, captchaResponse);
				} else {
					log.debug("Captcha validation parameter not found, do nothing");
				}
				if (continueWithChainProcessing) {
					if(log.isDebugEnabled()) {
						log.debug("Continuing with chain processing ...");
					}
					chain.doFilter(request, response);
				}
			}
		}
		else {
			chain.doFilter(servletRequest, servletResponse);
		}
	}
	/**
	 * Method validates captcha response and fires appropriate events.
	 * @param request
	 * @param response
	 * @param captchaResponse
	 *
	 * @return true if filter processing should continue, false when redirect was made
	 */
	private boolean validateCaptchaResponse(HttpServletRequest request, HttpServletResponse response, String captchaResponse) throws IOException {
		log.debug("Captcha validation parameter found, trying to validate");
		// validate the request against CaptchaServiceProxy
		HttpSession session = request.getSession();
		if(session != null) {
			String id = session.getId();
			boolean valid = false;
			try {
				valid = this.captchaService.validateReponseForId(id, captchaResponse);
			} catch(CaptchaServiceException ex) {
				if(log.isWarnEnabled()) {
					log.warn("Captcha already used. Returning false for recognition result!");
				}
			}
			log.debug("CaptchaServiceProxy says : request is valid = " + valid);
			if(valid) {
				log.debug("Captcha response accepted - updating context");
				((CaptchaSecurityContext)SecurityContextHolder.getContext()).setHuman();
				publisher.publishEvent(
						new CaptchaChallengePassedEvent(this, captchaResponse)
				);
				//if there is saved request redirect to it
				SavedRequest savedRequest = (SavedRequest)request.getSession()
						.getAttribute(SelfAwareCaptchaEntryPoint.CAPTCHA_ENTRY_POINT_SAVED_REQUEST_ATTRIBUTE);
				if (savedRequest != null) {
					String url = savedRequest.getFullRequestUrl();
					if(log.isDebugEnabled()) {
						log.debug("Original captcha requested url (" + url + ") found. Redirecting back because captcha was accepted.");
					}
					response.sendRedirect(url);
					return false;
				}
			}
			else {
				log.debug("Captcha response rejected - wrong answer");
				request.setAttribute(REQUEST_CAPTCHA_RECOGNITION_FAILURE_FLAG, Boolean.TRUE);
				publisher.publishEvent(
						new CaptchaChallengeFailedEvent(this, captchaResponse)
				);
			}
		}
		else {
			log.debug("No session found, user didn't even ask a captcha challenge");
		}
		return true;
	}
	/**
	 * This method just generates captcha image and skips request processing.
	 *
	 * @param request
	 * @param response
	 * @throws IOException
	 */
	private void generateImageOutputAndSkipProcessing(HttpServletRequest request, HttpServletResponse response) throws IOException {
		//we skip processing and return generated captcha image
		response.setHeader("Cache-Control", "no-store");
		response.setHeader("Pragma", "no-cache");
		response.setDateHeader("Expires", 0);
		response.setContentType("image/jpeg");
		// get the session id that will identify the generated captcha.
		//the same id must be used to validate the response, the session id is a good candidate!
		//generated image we stream directly onto output
		generateCaptcha(request.getSession().getId(), request.getLocale(), response.getOutputStream());
	}
	/**
	 * Generates the captcha image;
	 *
	 * @param captchaId
	 * @param locale
	 * @param os
	 * @throws IOException
	 */
	private void generateCaptcha(String captchaId, Locale locale, OutputStream os) throws IOException {
		if (jcaptchaService instanceof ImageCaptchaService) {
			BufferedImage challenge = ((ImageCaptchaService)jcaptchaService)
					.getImageChallengeForID(captchaId, locale);
			JPEGImageEncoder jpegEncoder = JPEGCodec.createJPEGEncoder(os);
			jpegEncoder.encode(challenge);
			// flush it in the response
			os.flush();
			os.close();
		} else {
			String msg = "CaptchaService does not implement ImageCaptchaService. Cannot generate image captcha.";
			log.error(msg);
		}
	}
}

@Intercepts(LifecycleStage.BindingAndValidation)
public class CaptchaValidationInterceptor implements Interceptor {
	/**
	 * Invoked when intercepting the flow of execution.
	 *
	 * @param context the ExecutionContext of the request currently being processed
	 * @return the result of calling context.proceed(), or if the interceptor wishes to change
	 *         the flow of execution, a Resolution
	 * @throws Exception if any non-recoverable errors occur
	 */
	public Resolution intercept(ExecutionContext context) throws Exception {
		Boolean captchaRecognitionFailed = (Boolean)context.getActionBeanContext()
				.getRequest().getAttribute(
				CaptchaGenerationValidationProcessingFilter.REQUEST_CAPTCHA_RECOGNITION_FAILURE_FLAG
		);
		if (captchaRecognitionFailed != null && captchaRecognitionFailed.booleanValue()) {
			context.getActionBeanContext().getValidationErrors().add(
					"captcha", new SimpleError("Chybně rozpoznaná captcha.")
			);
		}
		return context.proceed();
	}
}

<stripes:form action="/url.x" class="in" focus="">
<h3>Odeslat dotaz:</h3>
	<c:if test="<%=!((CaptchaSecurityContext)SecurityContextHolder.getContext()).isHuman()%>">
		<span id="captchaArea">
			<img id="captchaImage" src="/srv/www/generatedCaptchaImage.jpg" width="208" height="44">
			<span>
				<label for="captcha">Opište prosím text z obrázku:</label>
				<stripes:text id="captcha" name="captcha" class="text"/>
			</span>
		</span>
	</c:if>
	<stripes:submit name="createItem"/>
</stripes:form>