authentication with spring security

This commit is contained in:
EgorAnti
2026-10-19 21:11:48 +03:00
parent c324689cce
commit f0ec586777
13 changed files with 360 additions and 118 deletions
+1 -1
View File
@@ -25,7 +25,7 @@ dependencies {
implementation 'org.springframework.boot:spring-boot-starter-jdbc'
implementation 'org.flywaydb:flyway-core'
implementation 'org.flywaydb:flyway-database-postgresql'
implementation 'org.springframework.security:spring-security-crypto'
implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.bouncycastle:bcprov-jdk18on:1.84'
runtimeOnly 'org.postgresql:postgresql'
@@ -0,0 +1,85 @@
package com.example.mtusi_messenger.config;
import com.example.mtusi_messenger.security.ApiAuthenticationFilter;
import com.example.mtusi_messenger.security.DatabaseAuthenticationProvider;
import com.example.mtusi_messenger.security.RestAuthenticationEntryPoint;
import com.example.mtusi_messenger.service.AuthenticationService;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.ProviderManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.AnonymousAuthenticationFilter;
@Configuration
public class SecurityConfig {
@Bean
AuthenticationManager authenticationManager(DatabaseAuthenticationProvider provider) {
return new ProviderManager(provider);
}
@Bean
RestAuthenticationEntryPoint basicAuthenticationEntryPoint(ObjectMapper mapper) {
return new RestAuthenticationEntryPoint(
mapper,
"Basic realm=\"messenger\", charset=\"UTF-8\"");
}
@Bean
RestAuthenticationEntryPoint bearerAuthenticationEntryPoint(ObjectMapper mapper) {
return new RestAuthenticationEntryPoint(mapper, "Bearer realm=\"messenger\"");
}
@Bean
ApiAuthenticationFilter apiAuthenticationFilter(
AuthenticationManager authenticationManager,
AuthenticationService authenticationService,
@Qualifier("basicAuthenticationEntryPoint") RestAuthenticationEntryPoint basicAuthenticationEntryPoint,
@Qualifier("bearerAuthenticationEntryPoint") RestAuthenticationEntryPoint bearerAuthenticationEntryPoint
) {
return new ApiAuthenticationFilter(
authenticationManager,
authenticationService,
basicAuthenticationEntryPoint,
bearerAuthenticationEntryPoint);
}
@Bean
FilterRegistrationBean<ApiAuthenticationFilter> disableServletFilterRegistration(
ApiAuthenticationFilter filter
) {
var registration = new FilterRegistrationBean<>(filter);
registration.setEnabled(false);
return registration;
}
@Bean
SecurityFilterChain securityFilterChain(
HttpSecurity http,
ApiAuthenticationFilter apiAuthenticationFilter,
@Qualifier("bearerAuthenticationEntryPoint") RestAuthenticationEntryPoint bearerAuthenticationEntryPoint
) throws Exception {
http
.csrf(csrf -> csrf.disable())
.formLogin(form -> form.disable())
.httpBasic(basic -> basic.disable())
.logout(logout -> logout.disable())
.requestCache(cache -> cache.disable())
.sessionManagement(session -> session
.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.exceptionHandling(errors -> errors
.authenticationEntryPoint(bearerAuthenticationEntryPoint))
.authorizeHttpRequests(authorize -> authorize
.requestMatchers(HttpMethod.GET, "/health/**").permitAll()
.requestMatchers(HttpMethod.POST, "/api/v1/users").permitAll()
.anyRequest().authenticated())
.addFilterBefore(apiAuthenticationFilter, AnonymousAuthenticationFilter.class);
return http.build();
}
}
@@ -2,16 +2,16 @@ package com.example.mtusi_messenger.controller;
import com.example.mtusi_messenger.exception.ApiExceptions;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.*;
import com.example.mtusi_messenger.dto.*;
import com.example.mtusi_messenger.model.Chat;
import com.example.mtusi_messenger.service.ChatService;
import com.example.mtusi_messenger.service.AuthenticationService;
import com.example.mtusi_messenger.security.SessionPrincipal;
import java.util.List;
import java.util.UUID;
@@ -24,23 +24,22 @@ import static com.example.mtusi_messenger.service.UuidValidator.parse;
public class ChatController {
private final ChatService chats;
private final AuthenticationService authentication;
@PostMapping
public ResponseEntity<ChatResponse> create(HttpServletRequest req,
public ResponseEntity<ChatResponse> create(@AuthenticationPrincipal SessionPrincipal principal,
@Valid @RequestBody CreateChatRequest body
) {
UUID userId = authentication.requireBearer(req).id();
UUID userId = principal.user().id();
Chat c = chats.create(body, userId);
return ResponseEntity.status(HttpStatus.CREATED).body(ChatResponse.from(c));
}
@GetMapping
public ChatPageResponse list(HttpServletRequest req,
public ChatPageResponse list(@AuthenticationPrincipal SessionPrincipal principal,
@RequestParam(required = false) String limit,
@RequestParam(required = false) String cursor
) {
UUID userId = authentication.requireBearer(req).id();
UUID userId = principal.user().id();
int parsedLimit = validateLimit(limit);
validateCursorPresence(cursor);
List<Chat> page = chats.page(userId, parsedLimit, cursor);
@@ -51,10 +50,10 @@ public class ChatController {
}
@GetMapping("/{chatId}")
public ChatResponse get(HttpServletRequest req,
public ChatResponse get(@AuthenticationPrincipal SessionPrincipal principal,
@PathVariable String chatId
) {
UUID userId = authentication.requireBearer(req).id();
UUID userId = principal.user().id();
return ChatResponse.from(chats.getAccessible(parse(chatId), userId));
}
@@ -2,16 +2,16 @@ package com.example.mtusi_messenger.controller;
import com.example.mtusi_messenger.exception.ApiExceptions;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.*;
import com.example.mtusi_messenger.dto.*;
import com.example.mtusi_messenger.model.Message;
import com.example.mtusi_messenger.service.MessageService;
import com.example.mtusi_messenger.service.AuthenticationService;
import com.example.mtusi_messenger.security.SessionPrincipal;
import java.util.List;
import java.util.UUID;
@@ -23,26 +23,25 @@ import static com.example.mtusi_messenger.service.UuidValidator.parse;
@SecurityRequirement(name = "bearerAuth")
public class MessageController {
private final MessageService messages;
private final AuthenticationService authentication;
@PostMapping
public ResponseEntity<MessageResponse> create(HttpServletRequest req,
public ResponseEntity<MessageResponse> create(@AuthenticationPrincipal SessionPrincipal principal,
@PathVariable String chatId,
@Valid @RequestBody CreateMessageRequest body
) {
UUID userId = authentication.requireBearer(req).id();
UUID userId = principal.user().id();
UUID parsedChatId = parse(chatId);
Message m = messages.create(parsedChatId, userId, body);
return ResponseEntity.status(HttpStatus.CREATED).body(MessageResponse.from(m));
}
@GetMapping
public MessagePageResponse list(HttpServletRequest req,
public MessagePageResponse list(@AuthenticationPrincipal SessionPrincipal principal,
@PathVariable String chatId,
@RequestParam(required = false) String limit,
@RequestParam(required=false) String cursor
) {
UUID userId = authentication.requireBearer(req).id();
UUID userId = principal.user().id();
UUID parsedChatId = parse(chatId);
int parsedLimit = validateLimit(limit);
if (cursor != null && cursor.isBlank()) throw ApiExceptions.invalid("Invalid cursor");
@@ -3,11 +3,13 @@ package com.example.mtusi_messenger.controller;
import com.example.mtusi_messenger.dto.SessionResponse;
import com.example.mtusi_messenger.dto.UserResponse;
import com.example.mtusi_messenger.service.AuthenticationService;
import com.example.mtusi_messenger.model.User;
import com.example.mtusi_messenger.security.SessionPrincipal;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
@@ -21,8 +23,8 @@ public class SessionController {
@PostMapping
@SecurityRequirement(name = "basicAuth")
public ResponseEntity<SessionResponse> create(HttpServletRequest request) {
var issued = authentication.login(request);
public ResponseEntity<SessionResponse> create(@AuthenticationPrincipal User user) {
var issued = authentication.issueSession(user);
return ResponseEntity.status(HttpStatus.CREATED).body(new SessionResponse(
issued.token(),
"Bearer",
@@ -32,8 +34,8 @@ public class SessionController {
@DeleteMapping("/current")
@SecurityRequirement(name = "bearerAuth")
public ResponseEntity<Void> revoke(HttpServletRequest request) {
authentication.logout(request);
public ResponseEntity<Void> revoke(@AuthenticationPrincipal SessionPrincipal principal) {
authentication.revoke(principal);
return ResponseEntity.noContent().build();
}
}
@@ -1,15 +1,15 @@
package com.example.mtusi_messenger.controller;
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.*;
import com.example.mtusi_messenger.dto.*;
import com.example.mtusi_messenger.service.AuthenticationService;
import com.example.mtusi_messenger.service.UserService;
import com.example.mtusi_messenger.security.SessionPrincipal;
@RestController
@RequestMapping("/api/v1/users")
@@ -17,7 +17,6 @@ import com.example.mtusi_messenger.service.UserService;
public class UserController {
private final UserService users;
private final AuthenticationService authentication;
@PostMapping
public ResponseEntity<UserResponse> create(@Valid @RequestBody CreateUserRequest request) {
@@ -27,7 +26,7 @@ public class UserController {
@GetMapping("/me")
@SecurityRequirement(name = "bearerAuth")
public UserResponse me(HttpServletRequest request) {
return UserResponse.from(authentication.requireBearer(request));
public UserResponse me(@AuthenticationPrincipal SessionPrincipal principal) {
return UserResponse.from(principal.user());
}
}
@@ -0,0 +1,126 @@
package com.example.mtusi_messenger.security;
import com.example.mtusi_messenger.service.AuthenticationService;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Enumeration;
import java.util.List;
public class ApiAuthenticationFilter extends OncePerRequestFilter {
private static final String AUTHORIZATION = "Authorization";
private static final String SESSION_PATH = "/api/v1/auth/sessions";
private final AuthenticationManager authenticationManager;
private final AuthenticationService sessions;
private final RestAuthenticationEntryPoint basicEntryPoint;
private final RestAuthenticationEntryPoint bearerEntryPoint;
public ApiAuthenticationFilter(
AuthenticationManager authenticationManager,
AuthenticationService sessions,
RestAuthenticationEntryPoint basicEntryPoint,
RestAuthenticationEntryPoint bearerEntryPoint
) {
this.authenticationManager = authenticationManager;
this.sessions = sessions;
this.basicEntryPoint = basicEntryPoint;
this.bearerEntryPoint = bearerEntryPoint;
}
@Override
protected void doFilterInternal(
HttpServletRequest request,
HttpServletResponse response,
FilterChain filterChain
) throws ServletException, IOException {
boolean basicLogin = HttpMethod.POST.matches(request.getMethod())
&& SESSION_PATH.equals(request.getRequestURI());
if (isPublicRequest(request) && !basicLogin) {
filterChain.doFilter(request, response);
return;
}
try {
Authentication authentication = basicLogin
? authenticateBasic(request)
: authenticateBearer(request);
var context = SecurityContextHolder.createEmptyContext();
context.setAuthentication(authentication);
SecurityContextHolder.setContext(context);
filterChain.doFilter(request, response);
} catch (AuthenticationException e) {
SecurityContextHolder.clearContext();
(basicLogin ? basicEntryPoint : bearerEntryPoint)
.commence(request, response, e);
} finally {
SecurityContextHolder.clearContext();
}
}
private Authentication authenticateBasic(HttpServletRequest request) {
String header = singleAuthorizationHeader(request);
if (!header.startsWith("Basic ") || header.length() == 6) {
throw new BadCredentialsException("Invalid Basic credentials");
}
try {
byte[] decoded = Base64.getDecoder().decode(header.substring(6));
String credentials = new String(decoded, StandardCharsets.UTF_8);
int separator = credentials.indexOf(':');
if (separator <= 0) {
throw new BadCredentialsException("Invalid Basic credentials");
}
return authenticationManager.authenticate(
UsernamePasswordAuthenticationToken.unauthenticated(
credentials.substring(0, separator),
credentials.substring(separator + 1)));
} catch (IllegalArgumentException e) {
throw new BadCredentialsException("Invalid Basic credentials", e);
}
}
private Authentication authenticateBearer(HttpServletRequest request) {
String header = singleAuthorizationHeader(request);
if (!header.startsWith("Bearer ") || header.length() == 7) {
throw new BadCredentialsException("Invalid Bearer token");
}
String token = header.substring(7);
if (!token.matches("[A-Za-z0-9_-]{43}")) {
throw new BadCredentialsException("Invalid Bearer token");
}
SessionPrincipal principal = sessions.authenticateBearer(token);
return UsernamePasswordAuthenticationToken.authenticated(principal, null, List.of());
}
private String singleAuthorizationHeader(HttpServletRequest request) {
Enumeration<String> values = request.getHeaders(AUTHORIZATION);
if (values == null || !values.hasMoreElements()) {
throw new BadCredentialsException("Authentication required");
}
String value = values.nextElement();
if (values.hasMoreElements()) {
throw new BadCredentialsException("Multiple Authorization headers");
}
return value;
}
private boolean isPublicRequest(HttpServletRequest request) {
String path = request.getRequestURI();
return path.startsWith("/health/")
|| (HttpMethod.POST.matches(request.getMethod())
&& "/api/v1/users".equals(path));
}
}
@@ -0,0 +1,56 @@
package com.example.mtusi_messenger.security;
import com.example.mtusi_messenger.repository.UserRepository;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import java.util.List;
@Component
public class DatabaseAuthenticationProvider implements AuthenticationProvider {
private final UserRepository users;
private final PasswordEncoder passwordEncoder;
private final String dummyPasswordHash;
public DatabaseAuthenticationProvider(UserRepository users, PasswordEncoder passwordEncoder) {
this.users = users;
this.passwordEncoder = passwordEncoder;
this.dummyPasswordHash = passwordEncoder.encode("dummy-password-used-only-for-timing");
}
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
String username = authentication.getName();
String password = String.valueOf(authentication.getCredentials());
var stored = users.findCredentialsByUsername(username);
String passwordHash = stored.map(UserRepository.UserCredentials::passwordHash)
.filter(hash -> hash.startsWith("$argon2"))
.orElse(dummyPasswordHash);
boolean matches;
try {
matches = passwordEncoder.matches(password, passwordHash);
} catch (IllegalArgumentException e) {
matches = false;
}
if (stored.isEmpty() || !matches) {
throw new BadCredentialsException("Invalid credentials");
}
return UsernamePasswordAuthenticationToken.authenticated(
stored.get().user(),
null,
List.of());
}
@Override
public boolean supports(Class<?> authentication) {
return UsernamePasswordAuthenticationToken.class.isAssignableFrom(authentication);
}
}
@@ -0,0 +1,37 @@
package com.example.mtusi_messenger.security;
import com.example.mtusi_messenger.dto.ErrorResponse;
import com.example.mtusi_messenger.web.RequestIdFilter;
import com.fasterxml.jackson.databind.ObjectMapper;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.MediaType;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import java.io.IOException;
public class RestAuthenticationEntryPoint implements AuthenticationEntryPoint {
private final ObjectMapper mapper;
private final String challenge;
public RestAuthenticationEntryPoint(ObjectMapper mapper, String challenge) {
this.mapper = mapper;
this.challenge = challenge;
}
@Override
public void commence(
HttpServletRequest request,
HttpServletResponse response,
AuthenticationException exception
) throws IOException {
String requestId = (String) request.getAttribute(RequestIdFilter.ATTRIBUTE);
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
response.setCharacterEncoding("UTF-8");
response.setHeader("WWW-Authenticate", challenge);
mapper.writeValue(response.getOutputStream(), new ErrorResponse(
new ErrorResponse.ErrorBody("unauthorized", "Authentication required", requestId)));
}
}
@@ -0,0 +1,14 @@
package com.example.mtusi_messenger.security;
import com.example.mtusi_messenger.model.User;
public record SessionPrincipal(User user, byte[] tokenHash) {
public SessionPrincipal {
tokenHash = tokenHash.clone();
}
@Override
public byte[] tokenHash() {
return tokenHash.clone();
}
}
@@ -1,13 +1,12 @@
package com.example.mtusi_messenger.service;
import com.example.mtusi_messenger.exception.ApiExceptions;
import com.example.mtusi_messenger.model.Session;
import com.example.mtusi_messenger.model.User;
import com.example.mtusi_messenger.repository.SessionRepository;
import com.example.mtusi_messenger.repository.UserRepository;
import jakarta.servlet.http.HttpServletRequest;
import com.example.mtusi_messenger.security.SessionPrincipal;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.stereotype.Service;
import java.nio.charset.StandardCharsets;
@@ -16,24 +15,19 @@ import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.time.Instant;
import java.util.Base64;
import java.util.Enumeration;
import java.util.UUID;
@Service
public class AuthenticationService {
private static final String AUTHORIZATION = "Authorization";
private static final SecureRandom SECURE_RANDOM = new SecureRandom();
private final UserRepository users;
private final SessionRepository sessions;
private final PasswordEncoder passwordEncoder;
private final long ttlSeconds;
private final String dummyPasswordHash;
public AuthenticationService(
UserRepository users,
SessionRepository sessions,
PasswordEncoder passwordEncoder,
@Value("${messenger.session.ttl-seconds:3600}") long ttlSeconds
) {
if (ttlSeconds <= 0) {
@@ -41,30 +35,10 @@ public class AuthenticationService {
}
this.users = users;
this.sessions = sessions;
this.passwordEncoder = passwordEncoder;
this.ttlSeconds = ttlSeconds;
this.dummyPasswordHash = passwordEncoder.encode("dummy-password-used-only-for-timing");
}
public IssuedSession login(HttpServletRequest request) {
BasicCredentials credentials = parseBasic(singleAuthorizationHeader(request, true));
var stored = users.findCredentialsByUsername(credentials.username());
String passwordHash = stored.map(UserRepository.UserCredentials::passwordHash)
.filter(hash -> hash.startsWith("$argon2"))
.orElse(dummyPasswordHash);
boolean passwordMatches;
try {
passwordMatches = passwordEncoder.matches(credentials.password(), passwordHash);
} catch (IllegalArgumentException e) {
passwordMatches = false;
}
if (stored.isEmpty() || !passwordMatches) {
throw ApiExceptions.unauthorizedBasic("Invalid credentials");
}
User user = stored.get().user();
public IssuedSession issueSession(User user) {
String token = newToken();
Instant createdAt = Instant.now();
Instant expiresAt = createdAt.plusSeconds(ttlSeconds);
@@ -74,69 +48,24 @@ public class AuthenticationService {
hashToken(token),
createdAt,
expiresAt));
return new IssuedSession(token, expiresAt, user);
}
public User requireBearer(HttpServletRequest request) {
String token = parseBearer(singleAuthorizationHeader(request, false));
UUID userId = sessions.findActiveUserId(hashToken(token))
.orElseThrow(() -> ApiExceptions.unauthorizedBearer("Invalid or expired session"));
return users.findById(userId)
.orElseThrow(() -> ApiExceptions.unauthorizedBearer("Invalid or expired session"));
public SessionPrincipal authenticateBearer(String token) {
byte[] tokenHash = hashToken(token);
UUID userId = sessions.findActiveUserId(tokenHash)
.orElseThrow(() -> new BadCredentialsException("Invalid or expired session"));
User user = users.findById(userId)
.orElseThrow(() -> new BadCredentialsException("Invalid or expired session"));
return new SessionPrincipal(user, tokenHash);
}
public void logout(HttpServletRequest request) {
String token = parseBearer(singleAuthorizationHeader(request, false));
if (!sessions.revoke(hashToken(token))) {
throw ApiExceptions.unauthorizedBearer("Invalid or expired session");
public void revoke(SessionPrincipal principal) {
if (!sessions.revoke(principal.tokenHash())) {
throw new BadCredentialsException("Invalid or expired session");
}
}
private String singleAuthorizationHeader(HttpServletRequest request, boolean basic) {
Enumeration<String> values = request.getHeaders(AUTHORIZATION);
if (values == null || !values.hasMoreElements()) {
throw basic
? ApiExceptions.unauthorizedBasic("Authentication required")
: ApiExceptions.unauthorizedBearer("Authentication required");
}
String value = values.nextElement();
if (values.hasMoreElements()) {
throw basic
? ApiExceptions.unauthorizedBasic("Invalid Authorization header")
: ApiExceptions.unauthorizedBearer("Invalid Authorization header");
}
return value;
}
private BasicCredentials parseBasic(String header) {
if (!header.startsWith("Basic ") || header.length() == 6) {
throw ApiExceptions.unauthorizedBasic("Invalid credentials");
}
try {
byte[] decoded = Base64.getDecoder().decode(header.substring(6));
String value = new String(decoded, StandardCharsets.UTF_8);
int separator = value.indexOf(':');
if (separator <= 0) {
throw ApiExceptions.unauthorizedBasic("Invalid credentials");
}
return new BasicCredentials(value.substring(0, separator), value.substring(separator + 1));
} catch (IllegalArgumentException e) {
throw ApiExceptions.unauthorizedBasic("Invalid credentials");
}
}
private String parseBearer(String header) {
if (!header.startsWith("Bearer ") || header.length() == 7) {
throw ApiExceptions.unauthorizedBearer("Invalid bearer token");
}
String token = header.substring(7);
if (!token.matches("[A-Za-z0-9_-]{43}")) {
throw ApiExceptions.unauthorizedBearer("Invalid bearer token");
}
return token;
}
private String newToken() {
byte[] bytes = new byte[32];
SECURE_RANDOM.nextBytes(bytes);
@@ -153,5 +82,4 @@ public class AuthenticationService {
}
public record IssuedSession(String token, Instant expiresAt, User user) {}
private record BasicCredentials(String username, String password) {}
}
@@ -6,11 +6,14 @@ import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
import java.util.UUID;
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class RequestIdFilter extends OncePerRequestFilter {
public static final String HEADER = "X-Request-Id";
@@ -1,12 +1,6 @@
ALTER TABLE users
ADD COLUMN password_hash text;
-- V1 briefly existed without credentials. Such legacy rows cannot be given a
-- real password, so they receive a deliberately invalid value and cannot log in.
UPDATE users
SET password_hash = 'legacy-account-disabled'
WHERE password_hash IS NULL;
ALTER TABLE users
ALTER COLUMN password_hash SET NOT NULL;