🚧 Remove strategy, Add Drop match

This commit is contained in:
2026-06-28 18:21:26 +02:00
parent fc2454061f
commit 30665fdaa5
16 changed files with 113 additions and 163 deletions
@@ -7,6 +7,7 @@ import io.vertx.core.http.HttpServerRequest;
import io.vertx.core.http.HttpServerResponse;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.HttpHeaders;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import java.util.Set;
@@ -14,6 +15,8 @@ import java.util.Set;
@ApplicationScoped
public class LogoutService
{
private static final String SESSION_COOKIE_NAME = "session";
private static final String IDENTITY_COOKIE_NAME = "identity";
private static final String EMPTY = "";
@ConfigProperty(name = "oidc.proxy.logout.redirect.url")
@@ -24,16 +27,12 @@ public class LogoutService
public void logout(HttpServerRequest request, HttpServerResponse response)
{
String sessionId = getSessionId(request.cookies());
if (sessionId != null)
{
sessionCache.remove(sessionId);
}
sessionCache.remove(getSessionId(request.cookies()));
response.addCookie(Cookie.cookie("session", EMPTY).setMaxAge(0).setPath("/").setHttpOnly(true).setSecure(true));
response.addCookie(Cookie.cookie("identity", EMPTY).setMaxAge(0).setPath("/").setHttpOnly(false).setSecure(true));
response.addCookie(Cookie.cookie(SESSION_COOKIE_NAME, EMPTY).setMaxAge(0).setPath("/").setHttpOnly(true).setSecure(true));
response.addCookie(Cookie.cookie(IDENTITY_COOKIE_NAME, EMPTY).setMaxAge(0).setPath("/").setHttpOnly(false).setSecure(true));
response.setStatusCode(302);
response.putHeader("Location", logoutRedirectUrl);
response.putHeader(HttpHeaders.LOCATION, logoutRedirectUrl);
response.send();
}
@@ -41,7 +40,7 @@ public class LogoutService
{
for (Cookie cookie : cookies)
{
if ("session".equals(cookie.getName()))
if (SESSION_COOKIE_NAME.equals(cookie.getName()))
{
return cookie.getValue();
}
@@ -5,15 +5,16 @@ import dev.dinauer.oidcproxy.proxy.AccessLog;
import dev.dinauer.oidcproxy.proxy.ForwardService;
import dev.dinauer.oidcproxy.proxy.ResponseHandler;
import dev.dinauer.oidcproxy.proxy.TimedHttpResponse;
import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import dev.dinauer.oidcproxy.proxy.exception.ProxyHttpException;
import dev.dinauer.oidcproxy.proxy.exception.SessionNotFoundException;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException;
import java.io.IOException;
import java.net.ConnectException;
import java.net.http.HttpConnectTimeoutException;
import dev.dinauer.oidcproxy.startup.PathConverter;
import dev.dinauer.oidcproxy.startup.ProxyRoute;
import dev.dinauer.oidcproxy.startup.RouteService;
import io.quarkus.vertx.web.Route;
import io.smallrye.common.annotation.Blocking;
import io.vertx.core.http.HttpServerResponse;
import io.vertx.ext.web.RoutingContext;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
@@ -21,8 +22,9 @@ import jakarta.ws.rs.core.Context;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.http.HttpResponse;
import java.util.*;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
@ApplicationScoped
public class Resource
@@ -44,25 +46,25 @@ public class Resource
@Inject
AccessLog accessLog;
@Route(path = "/auth/callback", order = 0)
@Route(path = "/_auth/callback", order = 0)
@Blocking
public void callback(@Context RoutingContext context)
{
callbackService.get(context.response(), context.request());
callbackService.handleCodeExchange(context.response(), context.request());
}
@Route(path = "/auth/logout", order = 1)
@Route(path = "/_auth/logout", order = 1)
@Blocking
public void logout(@Context RoutingContext context)
{
logoutService.logout(context.request(), context.response());
}
@Route(path = "/api/*", order = 2)
@Route(path = "/*", order = 2)
@Blocking
public void proxy(@Context RoutingContext context)
{
String path = dropPrefix(context.request().path(), "/api");
String path = context.request().path();
Optional<ProxyRoute> match = routeService.match(path);
if (match.isPresent())
{
@@ -78,10 +80,14 @@ public class Resource
private void route(RoutingContext context, String path, ProxyRoute route)
{
List<String> requestSegments = PathConverter.toSegments(path);
if (route.dropMatch())
{
requestSegments = new LinkedList<>(requestSegments.subList(route.segments().size(), requestSegments.size()));
}
try
{
String targetURI = route.target() + PathConverter.toPath(requestSegments);
TimedHttpResponse<byte[]> response = forwardService.send(context, targetURI, route.strategy());
TimedHttpResponse<byte[]> response = forwardService.send(context, targetURI);
accessLog.log(AccessLog.Type.INFO, context, PathConverter.toPath(requestSegments), route.target(), response.response().statusCode(), response.time());
ResponseHandler.success(context, response.response());
}
@@ -90,28 +96,31 @@ public class Resource
accessLog.log(AccessLog.Type.ERROR, context, PathConverter.toPath(requestSegments), route.target(), e.getStatusCode(), e.getTime());
ResponseHandler.error(context, e.getStatusCode());
}
catch (TokenNotFoundException | SessionNotFoundException e)
catch (ProxyAuthenticationFailedException e)
{
LOG.error("Token / Session not found.", e);
LOG.error("Proxy authentication failed.", e);
ResponseHandler.error(context, 401);
}
catch (HttpConnectTimeoutException e)
{
LOG.error("Upstream connection timed out, returning 504.", e);
ResponseHandler.error(context, 504);
}
catch (ConnectException e)
{
LOG.error("Upstream not reachable, returning 502.", e);
ResponseHandler.error(context, 502);
}
catch (InterruptedException e)
{
LOG.error("Proxy request was interrupted, returning 503.", e);
Thread.currentThread().interrupt();
ResponseHandler.error(context, 503);
}
catch (Exception e)
catch (IOException e)
{
LOG.error("IO error during proxy request, returning 502.", e);
ResponseHandler.error(context, 502);
throw new RuntimeException(e);
}
}
private String dropPrefix(String pathRaw, String prefixRaw)
{
List<String> path = PathConverter.toSegments(pathRaw);
List<String> prefix = PathConverter.toSegments(prefixRaw);
return PathConverter.toPath(new LinkedList<>(path.subList(prefix.size(), path.size())));
}
}
@@ -10,8 +10,6 @@ import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import java.time.Instant;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
@ApplicationScoped
@@ -26,7 +24,7 @@ public class CallbackService
@ConfigProperty(name = "oidc.proxy.client.redirect")
String redirectURI;
public void get(HttpServerResponse response, HttpServerRequest request)
public void handleCodeExchange(HttpServerResponse response, HttpServerRequest request)
{
String code = request.params().get("code");
TokenResponse oidcResponse = client.exchangeAuthorizationCode(code);
@@ -1,8 +1,7 @@
package dev.dinauer.oidcproxy.proxy;
import dev.dinauer.oidcproxy.proxy.exception.ProxyHttpException;
import dev.dinauer.oidcproxy.proxy.exception.SessionNotFoundException;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException;
import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import dev.dinauer.oidcproxy.session.SessionCache;
import dev.dinauer.oidcproxy.proxy.header.HeaderFilter;
import dev.dinauer.oidcproxy.request.HttpRequestBuilder;
@@ -24,13 +23,13 @@ public class ForwardService
@Inject
HeaderFilter headerFilter;
public TimedHttpResponse<byte[]> send(RoutingContext context, String route, String strategy) throws IOException, InterruptedException, ProxyHttpException, TokenNotFoundException, SessionNotFoundException
public TimedHttpResponse<byte[]> send(RoutingContext context, String route) throws IOException, InterruptedException, ProxyHttpException, ProxyAuthenticationFailedException
{
HttpRequestBuilder builder = HttpRequestBuilder.create();
builder.setUri(route);
builder.setParams(context.request().params().entries());
builder.setMethod(context.request().method().toString());
builder.setHeaders(headerFilter.filter(context.request(), strategy));
builder.setHeaders(headerFilter.filter(context.request()));
builder.setBody(extractBody(context));
long start = System.currentTimeMillis();
@@ -42,7 +41,10 @@ public class ForwardService
{
return new TimedHttpResponse<>(time, response);
}
throw new ProxyHttpException(time, response.statusCode());
else
{
throw new ProxyHttpException(time, response.statusCode());
}
}
private byte[] extractBody(RoutingContext context)
@@ -0,0 +1,9 @@
package dev.dinauer.oidcproxy.proxy.exception;
public class ProxyAuthenticationFailedException extends Exception
{
public ProxyAuthenticationFailedException()
{
super();
}
}
@@ -1,8 +0,0 @@
package dev.dinauer.oidcproxy.proxy.exception;
public class SessionNotFoundException extends Exception
{
public SessionNotFoundException()
{
}
}
@@ -1,9 +0,0 @@
package dev.dinauer.oidcproxy.proxy.exception;
public class TokenNotFoundException extends Exception
{
public TokenNotFoundException()
{
super();
}
}
@@ -1,37 +1,66 @@
package dev.dinauer.oidcproxy.proxy.header;
import dev.dinauer.oidcproxy.proxy.exception.SessionNotFoundException;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException;
import dev.dinauer.oidcproxy.proxy.header.strategy.OidcStrategy;
import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import dev.dinauer.oidcproxy.session.SessionCache;
import io.quarkus.security.UnauthorizedException;
import io.vertx.core.http.Cookie;
import io.vertx.core.http.HttpServerRequest;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.BadRequestException;
import org.apache.commons.lang3.Strings;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
@ApplicationScoped
public class HeaderFilter
{
private static final String AUTH_HEADER = "Authorization";
private static final List<String> HOP2HOP = List.of("keep-alive", "transfer-encoding", "te", "connection", "trailer", "upgrade", "proxy-authenticate", "proxy-authorization");
@Inject
OidcStrategy oidcStrategy;
SessionCache sessionCache;
public List<Map.Entry<String, String>> filter(HttpServerRequest request, String strategy) throws TokenNotFoundException, SessionNotFoundException
public List<Map.Entry<String, String>> filter(HttpServerRequest request) throws ProxyAuthenticationFailedException
{
List<Map.Entry<String, String>> headers = filterHop2HopHeaders(request.headers().entries());
if ("OIDC".equals(strategy))
Optional<String> token = getAccessToken(request);
if (!hasAuthHeader(headers) && token.isPresent())
{
headers = oidcStrategy.filter(request, headers);
headers.add(Map.entry(AUTH_HEADER, String.format("Bearer %s", token.get())));
}
return headers;
}
private Optional<String> getAccessToken(HttpServerRequest request) throws ProxyAuthenticationFailedException
{
Set<Cookie> sessions = request.cookies("session");
if (sessions.isEmpty())
{
return Optional.empty();
}
if (sessions.size() == 1)
{
return Optional.of(sessionCache.get(sessions.iterator().next().getValue()));
}
throw new BadRequestException();
}
private boolean hasAuthHeader(List<Map.Entry<String, String>> headers)
{
for (Map.Entry<String, String> header : headers)
{
if (Strings.CI.equals(AUTH_HEADER, header.getKey()))
{
return true;
}
}
return false;
}
private List<Map.Entry<String, String>> filterHop2HopHeaders(List<Map.Entry<String, String>> input)
{
List<Map.Entry<String, String>> result = new LinkedList<>();
@@ -1,15 +0,0 @@
package dev.dinauer.oidcproxy.proxy.header.strategy;
import jakarta.enterprise.context.ApplicationScoped;
import java.util.List;
import java.util.Map;
@ApplicationScoped
public class NoneStrategy
{
public List<Map.Entry<String, String>> filter(List<Map.Entry<String, String>> input)
{
return input;
}
}
@@ -1,65 +0,0 @@
package dev.dinauer.oidcproxy.proxy.header.strategy;
import dev.dinauer.oidcproxy.proxy.exception.SessionNotFoundException;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException;
import dev.dinauer.oidcproxy.session.SessionCache;
import io.quarkus.security.UnauthorizedException;
import io.vertx.core.http.Cookie;
import io.vertx.core.http.HttpServerRequest;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.BadRequestException;
import jakarta.ws.rs.WebApplicationException;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.commons.lang3.Strings;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
@ApplicationScoped
public class OidcStrategy
{
private static final String AUTH_HEADER = "Authorization";
@Inject
SessionCache sessionCache;
public List<Map.Entry<String, String>> filter(HttpServerRequest request, List<Map.Entry<String, String>> input) throws TokenNotFoundException, SessionNotFoundException
{
Optional<String> tokenOptional = getAccessToken(request);
if (!hasAuthHeader(input) && tokenOptional.isPresent())
{
input.add(Map.entry(AUTH_HEADER, String.format("Bearer %s", tokenOptional.get())));
}
return input;
}
private Optional<String> getAccessToken(HttpServerRequest request) throws TokenNotFoundException
{
Set<Cookie> sessions = request.cookies("session");
if (sessions.size() == 1)
{
String session = sessions.iterator().next().getValue();
return Optional.of(sessionCache.get(session));
}
if (sessions.isEmpty())
{
return Optional.empty();
}
throw new BadRequestException();
}
private boolean hasAuthHeader(List<Map.Entry<String, String>> input)
{
for (Map.Entry<String, String> header : input)
{
if (Strings.CI.equals(AUTH_HEADER, header.getKey()))
{
return true;
}
}
return false;
}
}
@@ -1,11 +1,12 @@
package dev.dinauer.oidcproxy.session;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException;
import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import io.quarkus.narayana.jta.QuarkusTransaction;
import io.quarkus.runtime.Startup;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.context.control.ActivateRequestContext;
import jakarta.inject.Inject;
import org.apache.commons.lang3.StringUtils;
import org.jboss.logging.Logger;
import java.security.MessageDigest;
@@ -31,7 +32,7 @@ public class SessionCache
return sessionId;
}
public String get(String sessionId) throws TokenNotFoundException
public String get(String sessionId) throws ProxyAuthenticationFailedException
{
String sessionHash = toHash(sessionId);
Optional<String> token = getFromCache(sessionHash);
@@ -46,9 +47,12 @@ public class SessionCache
public void remove(String sessionId)
{
String sessionHash = toHash(sessionId);
tokens.remove(sessionHash);
sessionService.remove(sessionHash);
if (!StringUtils.isBlank(sessionId))
{
String sessionHash = toHash(sessionId);
tokens.remove(sessionHash);
sessionService.remove(sessionHash);
}
}
public Optional<String> getFromCache(String sessionHash)
@@ -3,7 +3,7 @@ package dev.dinauer.oidcproxy.session;
import dev.dinauer.oidcproxy.JwtUtils;
import dev.dinauer.oidcproxy.callback.OidcClient;
import dev.dinauer.oidcproxy.callback.model.TokenResponse;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException;
import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import io.quarkus.security.UnauthorizedException;
import io.smallrye.jwt.auth.principal.DefaultJWTParser;
import jakarta.enterprise.context.ApplicationScoped;
@@ -49,7 +49,7 @@ public class SessionService
}
@Transactional
public AccessToken provide(String sessionHash) throws TokenNotFoundException
public AccessToken provide(String sessionHash) throws ProxyAuthenticationFailedException
{
AccessTokenEntity dbToken = accessTokenRepository.findById(sessionHash);
if (isValid(dbToken))
@@ -74,11 +74,11 @@ public class SessionService
}
catch (Exception e)
{
throw new TokenNotFoundException();
throw new ProxyAuthenticationFailedException();
}
}
throw new TokenNotFoundException();
throw new ProxyAuthenticationFailedException();
}
@Transactional
@@ -2,7 +2,7 @@ package dev.dinauer.oidcproxy.startup;
import java.util.List;
public record ProxyRoute(String path, String target, String strategy)
public record ProxyRoute(String path, String target, boolean dropMatch)
{
public String path()
{
@@ -37,17 +37,14 @@ public class RouteService
List<ProxyRoute> result = new LinkedList<>();
for (ConfigRoute route : rules.routes())
{
if (StringUtils.isBlank(route.strategy()))
{
throw new IllegalArgumentException();
}
boolean dropMatch = Boolean.TRUE.equals(route.dropMatch());
if (StringUtils.isBlank(rules.root()))
{
result.add(new ProxyRoute(route.path(), route.target(), route.strategy()));
result.add(new ProxyRoute(route.path(), route.target(), dropMatch));
}
else
{
result.add(new ProxyRoute(StringUtils.join(rules.root(), route.path()), route.target(), route.strategy()));
result.add(new ProxyRoute(StringUtils.join(rules.root(), route.path()), route.target(), dropMatch));
}
}
for (ProxyRoute route : result)
@@ -1,11 +1,11 @@
package dev.dinauer.oidcproxy.startup.model;
import com.fasterxml.jackson.annotation.JsonProperty;
import dev.dinauer.oidcproxy.startup.PathConverter;
import org.apache.commons.lang3.StringUtils;
import java.util.List;
public record ConfigRoute(String path, String target, String strategy)
public record ConfigRoute(String path, String target, @JsonProperty("drop-match") Boolean dropMatch)
{
public List<String> segments()
{
+1 -1
View File
@@ -1,4 +1,4 @@
routes:
- path: /
target: http://localhost:8081
strategy: OIDC
drop-match: true