Request body change when I Use servletRequest.getReader().lines().collect(Collectors.joining())

Question

I'm doing a private api in java, jwt, spring security and the first time come in the request a json object

user: xxx password: yyy

and the api return a jwt token in the body

the others call the token come in the body json and to validate it I use this:

sbody = servletRequest.getReader().lines().collect(Collectors.joining());

to get the field token and it get ok, but then of the filter it show the message:

"Required request body is missing: public org.springframework.http.ResponseEntity"

this is my api:

@SpringBootApplication
public class JwtApplication {

    public static void main(String[] args) {
        SpringApplication.run(JwtApplication.class, args);
    }

    @EnableWebSecurity
    @Configuration
    class WebSecurityConfig extends WebSecurityConfigurerAdapter {

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http.csrf().disable()
                    .addFilterAfter(new JWTAuthorizationFilter(), UsernamePasswordAuthenticationFilter.class)
                    .authorizeRequests().antMatchers(HttpMethod.POST, "/user").permitAll()
                    .antMatchers(HttpMethod.POST, "/Autenticacion").permitAll().anyRequest().authenticated();
        }

    }
}

this is the filter:

public class JWTAuthorizationFilter extends OncePerRequestFilter {

    private final String HEADER = "Authorization";
    private final String SESSION = "sesion";
    private final String PREFIX = "Bearer ";
    private final String SECRET = "mySecretKey";
    public static final long EXPIRATION_TIME = 900_000; // 15 mins

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        try {
            boolean resultado_checktoken = checkJWTToken(httpRequest, httpResponse);
            if (resultado_checktoken) {
                Claims claims = validateToken(request);
                if (claims.get("authorities") != null) {
                    setUpSpringAuthentication(claims);
                } else {
                    SecurityContextHolder.clearContext();
                }
            } else {
                SecurityContextHolder.clearContext();
            }
            chain.doFilter(request, response);
        } catch (ExpiredJwtException | UnsupportedJwtException | MalformedJwtException e) {
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
            ((HttpServletResponse) response).sendError(HttpServletResponse.SC_FORBIDDEN, e.getMessage());
            return;
        }
         System.out.println("supuestamente no hubo problemas");
    }

    private Claims validateToken(HttpServletRequest request) {
        //String jwtToken = request.getHeader(HEADER).replace(PREFIX, "");
        String jwtToken="";
        try {
            jwtToken = this.getBodySession(request);
        } catch (IOException e) {
            e.printStackTrace();
        };
        return Jwts.parser().setSigningKey(SECRET.getBytes()).parseClaimsJws(jwtToken).getBody();
    }
    
    /**
     * Authentication method in Spring flow
     * 
     * @param claims
     */
    private void setUpSpringAuthentication(Claims claims) {
        @SuppressWarnings("unchecked")
        List<String> authorities = (List<String>) claims.get("authorities");
        UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken(claims.getSubject(), null,
                authorities.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList()));
        SecurityContextHolder.getContext().setAuthentication(auth);
    }

    private boolean checkJWTToken(HttpServletRequest request, HttpServletResponse res) throws IOException {
        String authenticationHeader = "";
        authenticationHeader = this.getBodySession(request);
        if (authenticationHeader == null || !authenticationHeader.startsWith(PREFIX))
            return false;
        return true;
    }

    public String getBodySession(HttpServletRequest request) throws IOException {
        String sbody = "";
        HttpServletRequest servletRequest = new ContentCachingRequestWrapper(request);
        //servletRequest.getParameterMap();
        sbody = servletRequest.getReader().lines().collect(Collectors.joining());
        String Field = SESSION;
        String scampo = "";
        if (sbody.contains(Field)) {
            scampo = sbody.substring(sbody.indexOf(Field), sbody.indexOf("\n", sbody.indexOf(Field)))
                    .replace(Field + "\": \"", "").replace("\"", "").replace(",", "");
        }
        System.out.println("sbody: " + sbody + " sesion: " + scampo);
        return scampo;
    }
}

Answer 1

This needs to return a boolean explicitly you cannot have two return statements.

private boolean checkJWTToken(HttpServletRequest request, HttpServletResponse res) throws IOException {
        String authenticationHeader = "";
        authenticationHeader = this.getBodySession(request);
        if (authenticationHeader == null || !authenticationHeader.startsWith(PREFIX))
            **return false;**
        **return true;**
    }