Merge pull request 'Implémentation des proxies "passthrough"' (#30) from passthrough-proxy into develop

Reviewed-on: #30

.env.dist

@@ -0,0 +1 @@
+GODEBUG="http1debug=2 http2debug=2"

.goreleaser.yaml

@@ -63,6 +63,9 @@ nfpms:
       - src: layers
         dst: /etc/bouncer/layers
         type: config
+      - src: templates
+        dst: /etc/bouncer/templates
+        type: config
       - dst: /etc/bouncer/bootstrap.d
         type: dir
         file_info:

Dockerfile

@@ -22,6 +22,7 @@ RUN make GORELEASER_ARGS='build --rm-dist --single-target --snapshot' goreleaser
 
 # Patch config
 RUN /src/dist/bouncer_linux_amd64_v1/bouncer -c '' config dump > /src/dist/bouncer_linux_amd64_v1/config.yml \
+&& yq -i '.proxy.templates.dir = "/usr/share/bouncer/templates"' /src/dist/bouncer_linux_amd64_v1/config.yml \
     && yq -i '.layers.queue.templateDir = "/usr/share/bouncer/layers/queue/templates"' /src/dist/bouncer_linux_amd64_v1/config.yml \
     && yq -i '.layers.authn.templateDir = "/usr/share/bouncer/layers/authn/templates"' /src/dist/bouncer_linux_amd64_v1/config.yml \
     && yq -i '.admin.auth.privateKey = "/etc/bouncer/admin-key.json"' /src/dist/bouncer_linux_amd64_v1/config.yml \
@@ -42,6 +43,7 @@ RUN mkdir -p /usr/local/bin /usr/share/bouncer/bin /etc/bouncer
 
 COPY --from=BUILD /src/dist/bouncer_linux_amd64_v1/bouncer /usr/share/bouncer/bin/bouncer
 COPY --from=BUILD /src/layers /usr/share/bouncer/layers
+COPY --from=BUILD /src/templates /usr/share/bouncer/templates
 COPY --from=BUILD /src/dist/bouncer_linux_amd64_v1/config.yml /etc/bouncer/config.yml
 
 RUN ln -s /usr/share/bouncer/bin/bouncer /usr/local/bin/bouncer

README.md

@@ -4,7 +4,16 @@
 
 # Bouncer
 
-Serveur mandataire inverse (_"reverse proxy"_) filtrant avec gestion de files d'attente dynamiques.
+Serveur mandataire inverse (_"reverse proxy"_) avec fonctionnalités avancées pilotable par API REST.
+
+## Fonctionnalités
+
+- Authentification unique basée sur entêtes HTTP ("Trusted headers SSO") avec:
+  - Fournisseur d'identité OpenID Connect ;
+  - Basic Auth ;
+  - Origine réseau ;
+- Gestion de files d'attente dynamiques pour maîtriser la charge sur les services protégés ;
+- Réécriture dynamique des attributs (notamment entêtes HTTP) des requêtes/réponses via un DSL.
 
 ## Documentation
 
@@ -12,4 +21,4 @@ Serveur mandataire inverse (_"reverse proxy"_) filtrant avec gestion de files d'
 
 ## Licence
 
-AGPL-3.0
+AGPL-3.0

doc/README.md

@@ -1,7 +1,8 @@
 # Documentation
 
-- [(FR) - Premiers pas](./fr/getting-started.md)
 - [(FR) - Architecture générale](./fr/general-architecture.md)
+- [(FR) - Terminologie](./fr/terminology.md)
+- [(FR) - Premiers pas](./fr/getting-started.md)
 
 ## Exemples
 

doc/fr/general-architecture.md

@@ -2,31 +2,6 @@
 
 ## Modèles de déploiement
 
-### Déploiement mono-noeud
+### Mode mono-noeud
 
-![](../resources/deployment_fr.png)
-
-## Terminologie
-
-Voici une liste des termes utilisés dans le lexique Bouncer.
-
-### Proxy
-
-Un "proxy" est une entité logique définissant le relation suivante:
-
-- Un ou plusieurs patrons de filtrage sous la forme d'un patron d'URL avec le caractère `*` comme caractère générique. Ceux ci identifient le ou les domaines/chemins associés à l'entité;
-- Une URL cible qui servira de base pour la réécriture des requêtes.
-
-Un "proxy" peut avoir zéro ou plusieurs "layers" associés.
-
-Un "proxy" peut être activé ou désactivé.
-
-Un "proxy" a un poids qui définit son niveau de priorité dans la pile de traitement (plus son poids est élevé plus il est prioritaire).
-
-### Layer
-
-Un "layer" (calque) est une entité logique définissant un traitement à appliquer aux requêtes et/ou aux réponses transitant par un proxy.
-
-Un "layer" peut être activé ou désactivé.
-
-Un "layer" a un poids qui définit son niveau de priorité dans la pile de traitement (plus son poids est élevé plus il est prioritaire).
+![](../resources/deployment_single_node_fr.png)

doc/fr/references/layers/README.md

@@ -4,3 +4,4 @@ Vous trouverez ci-dessous la liste des entités "Layer" activables sur vos entit
 
 - [Authn (`authn-*`)](./authn/README.md) - Authentification des accès (SSO)
 - [Queue](./queue.md) - File d'attente dynamique
+- [Rewriter](./rewriter.md) - Réécriture dynamiques des attributs des requêtes/réponses

doc/fr/references/layers/authn/README.md

@@ -36,16 +36,28 @@ Le comportement des règles par défaut est le suivant:
 
 Interdire l'accès à l'utilisateur.
 
-#### `set_header(name string, value string)`
+##### `add_header(name string, value string)`
 
-Définir la valeur d'une entête HTTP via son nom `name` et sa valeur `value`.
+Ajouter une valeur à un entête HTTP via son nom `name` et sa valeur `value`.
 
-#### `del_headers(pattern string)`
+##### `set_header(name string, value string)`
+
+Définir la valeur d'un entête HTTP via son nom `name` et sa valeur `value`. La valeur précédente est écrasée.
+
+##### `del_headers(pattern string)`
 
 Supprimer un ou plusieurs entêtes HTTP dont le nom correspond au patron `pattern`.
 
 Le patron est défini par une chaîne comprenant un ou plusieurs caractères `*`, signifiant un ou plusieurs caractères arbitraires.
 
+##### `set_host(host string)`
+
+Modifier la valeur de l'entête `Host` de la requête.
+
+##### `set_url(url string)`
+
+Modifier l'URL du serveur cible.
+
 ### Environnement
 
 Les règles ont accès aux variables suivantes pendant leur exécution.

doc/fr/references/layers/rewriter.md

@@ -0,0 +1,116 @@
+# Layer "Rewriter"
+
+## Description
+
+Ce layer permet de modifier dynamiquement certains attributs de requêtes/réponses transitant par le proxy.
+
+## Type
+
+`rewriter`
+
+## Schéma des options
+
+Les options disponibles pour le layer sont décrites via un [schéma JSON](https://json-schema.org/specification). Elles sont documentées dans le [schéma visible ici](../../../../internal/proxy/director/layer/rewriter/layer-options.json).
+
+## Moteur de règles
+
+Les options `rules.request` et `rules.response` permettent de définir des listes de règles utilisant un DSL modifiant de manière dynamique les attributs des requêtes/réponses transitant par le proxy.
+
+Les listes d'instructions sont exécutées séquentiellement.
+
+Bouncer utilise le projet [`expr`](https://expr-lang.org/) comme DSL. En plus des fonctionnalités natives du langage, Bouncer ajoute un certain nombre de fonctions spécifiques au contexte d'utilisation.
+
+### Fonctions
+
+#### Communes
+
+##### `add_header(name string, value string)`
+
+Ajouter une valeur à un entête HTTP via son nom `name` et sa valeur `value`.
+
+##### `set_header(name string, value string)`
+
+Définir la valeur d'un entête HTTP via son nom `name` et sa valeur `value`. La valeur précédente est écrasée.
+
+##### `del_headers(pattern string)`
+
+Supprimer un ou plusieurs entêtes HTTP dont le nom correspond au patron `pattern`.
+
+Le patron est défini par une chaîne comprenant un ou plusieurs caractères `*`, signifiant un ou plusieurs caractères arbitraires.
+
+#### Requête
+
+##### `set_host(host string)`
+
+Modifier la valeur de l'entête `Host` de la requête.
+
+##### `set_url(url string)`
+
+Modifier l'URL du serveur cible.
+
+#### Réponse
+
+_Pas de fonctions spécifiques._
+
+### Environnement
+
+Les règles ont accès aux variables suivantes pendant leur exécution. **Ces données sont en lecture seule.**
+
+#### Requête
+
+##### `request`
+
+La requête en cours de traitement.
+
+```js
+{
+    method: "string", // Méthode HTTP
+    host: "string", // Nom d'hôte (`Host`) associé à la requête
+    url: "string", // URL associée à la requête
+    proto: "string", // Numéro de version du protocole utilisé
+    protoMajor: "int", // Numéro de version majeure du protocole utilisé
+    protoMinor: "int",  // Numéro de version mineur du protocole utilisé
+    header: { // Table associative des entêtes HTTP associés à la requête
+        "string": ["string"]
+    },
+    contentLength: "int", // Taille du corps de la requête
+    transferEncoding: ["string"], // MIME-Type(s) d'encodage du corps de la requête
+    trailer: { // Table associative des entêtes HTTP associés à la requête, transmises après le corps de la requête
+        "string": ["string"]
+    },
+    remoteAddr: "string", // Adresse du client HTTP à l'origine de la requête
+    requestUri: "string" // URL "brute" associée à la requêtes (avant opérations d'assainissement, utiliser "url" plutôt)
+}
+```
+
+#### Réponse
+
+##### `response`
+
+La réponse en cours de traitement.
+
+```js
+{
+    statusCode: "int", // Code de statut de la réponse
+    status: "string", // Message associé au code de statut
+    proto: "string", // Numéro de version du protocole utilisé
+    protoMajor: "int", // Numéro de version majeure du protocole utilisé
+    protoMinor: "int",  // Numéro de version mineur du protocole utilisé
+    header: { // Table associative des entêtes HTTP associés à la requête
+        "string": ["string"]
+    },
+    contentLength: "int", // Taille du corps de la réponse
+    transferEncoding: ["string"], // MIME-Type(s) d'encodage du corps de la requête
+    trailer: { // Table associative des entêtes HTTP associés à la requête, transmises après le corps de la requête
+        "string": ["string"]
+    },
+}
+```
+
+##### `request`
+
+_Voir section précédente._
+
+## Métriques
+
+_Pas de métriques spécifiques._

doc/fr/terminology.md

@@ -0,0 +1,29 @@
+# Terminologie
+
+Voici une liste des termes utilisés dans le lexique Bouncer.
+
+## Proxy
+
+Un proxy est une entité logique définie par les propriétés suivantes:
+
+- Il possède **un ou plusieurs filtres d'origine** sous la forme de motifs d'URL avec le caractère `*` comme joker. Ces filtres identifient le ou les URLs associées au proxy.
+- Il peut avoir **zéro ou une URL cible**, qui servira de base pour la réécriture des requêtes. Si l'URL est absente, on parle alors de "passthrough" (voir note).
+- Il peut avoir **zéro ou plusieurs "layers" associés**.
+- Il peut être **activé ou désactivé**.
+- Il a **un poids qui définit son niveau de priorité** dans la pile de traitement (plus son poids est élevé plus il est prioritaire).
+
+Pour résumer un proxy répond à la question "_Quelle URL orienter vers quel serveur cible ?_".
+
+> **Passthrough**
+>
+> Un proxy "passthrough" est un proxy n'ayant pas d'URL cible (champ vide). Dans ce cas si les motifs d'URLs correspondent à l'URL de la requête Bouncer appliquera les layers associés puis passera la main aux proxies suivants.
+
+## Layer
+
+Un layer est une entité logique définie par les propriétés suivantes:
+
+- Il a **un type auquel est associé un schéma d'options** permettant de configurer son comportement.
+- Il peut être **activé ou désactivé**.
+- Il a **un poids qui définit son niveau de priorité** dans la pile de traitement (plus son poids est élevé plus il est prioritaire).
+
+Pour résumer un layer répond à la question "_Quel traitement appliquer à la requête et/ou réponse ?_".

doc/fr/tutorials/create-custom-layer.md

@@ -10,13 +10,13 @@ Avoir un environnement de développement local fonctionnel. Voir tutoriel ["Dém
 
 ### Préparer la structure de base du nouveau layer
 
-Une implémetation d'un layer se compose majoritairement de 3 éléments:
+Une implémentation d'un layer se compose majoritairement de 3 éléments:
 
 - Une structure qui implémente une ou plusieurs interfaces (`director.MiddlewareLayer`, `director.RequestTransformerLayer` et/ou `director.ResponseTransformerLayer`);
 - Un schéma au format [JSON Schema](http://json-schema.org/) qui permettra de valider les "options" de notre layer;
 - Un fichier d'amorçage qui permettra à Bouncer de référencer notre nouveau layer.
 
-1. Créer le répertoire du `package` Go qui contiendra le code de votre layer. Celui ci s'appelera `basicauth`:
+1. Créer le répertoire du `package` Go qui contiendra le code de votre layer. Celui ci s’appellera `basicauth`:
 
    ```
    mkdir -p internal/proxy/director/layer/basicauth
@@ -133,26 +133,22 @@ Une implémetation d'un layer se compose majoritairement de 3 éléments:
 
 ## Tester l'intégration de notre nouveau layer
 
-À ce stade, notre nouveau layer est normalement référencé et donc "utilisable" dans Bouncer (si on omet le fait qu'il déclenchera une `panic()`).
+À ce stade, notre nouveau layer est normalement référencé et donc "utilisable" dans Bouncer (si on omet le fait qu'il déclenchera un `panic()`).
 
 1. Vérifier que notre layer est bien référencé en exécutant la commande:
 
    ```
-   ./bin/bouncer admin layer create --help
+   ./bin/bouncer admin definition layer query --with-type basicauth
    ```
 
    La sortie devrait ressembler à:
 
    ```
-   NAME:
-   bouncer admin layer create - Create layer
-
-   USAGE:
-   bouncer admin layer create [command options] [arguments...]
-
-   OPTIONS:
-   --layer-type LAYER_TYPE        Set LAYER_TYPE as layer's type (available: [basicauth queue])
-   [...]
+    +-----------+-----------------------------------+
+    | TYPE      | OPTIONS                           |
+    +-----------+-----------------------------------+
+    | basicauth | {"type":"object","properties":... |
+    +-----------+-----------------------------------+
    ```
 
    Comme vous devriez le voir nous pouvons désormais créer des layers de type `basicauth`.

go.mod

@@ -5,7 +5,7 @@ go 1.21
 toolchain go1.22.0
 
 require (
-	forge.cadoles.com/Cadoles/go-proxy v0.0.0-20230701194111-c6b3d482cca6
+	forge.cadoles.com/Cadoles/go-proxy v0.0.0-20240626132607-e1db6466a926
 	github.com/Masterminds/sprig/v3 v3.2.3
 	github.com/bsm/redislock v0.9.4
 	github.com/btcsuite/btcd/btcutil v1.1.3

go.sum

@@ -10,6 +10,8 @@ cloud.google.com/go/longrunning v0.5.1 h1:Fr7TXftcqTudoyRJa113hyaqlGdiBQkp0Gq7tE
 cloud.google.com/go/longrunning v0.5.1/go.mod h1:spvimkwdz6SPWKEt/XBij79E9fiTkHSQl/fRUUQJYJc=
 forge.cadoles.com/Cadoles/go-proxy v0.0.0-20230701194111-c6b3d482cca6 h1:FTk0ZoaV5N8Tkps5Da5RrDMZZXSHZIuD67Hy1Y4fsos=
 forge.cadoles.com/Cadoles/go-proxy v0.0.0-20230701194111-c6b3d482cca6/go.mod h1:o8ZK5v/3J1dRmklFVn1l6WHAyQ3LgegyHjRIT8KLAFw=
+forge.cadoles.com/Cadoles/go-proxy v0.0.0-20240626132607-e1db6466a926 h1:gSTTuW2lqH66cGVrhplrVrqos62BY1/GxR3KYh2TElk=
+forge.cadoles.com/Cadoles/go-proxy v0.0.0-20240626132607-e1db6466a926/go.mod h1:o8ZK5v/3J1dRmklFVn1l6WHAyQ3LgegyHjRIT8KLAFw=
 github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8=
 github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=

internal/admin/proxy_route.go

@@ -121,7 +121,7 @@ func (s *Server) deleteProxy(w http.ResponseWriter, r *http.Request) {
 
 type CreateProxyRequest struct {
 	Name string   `json:"name" validate:"required"`
-	To   string   `json:"to" validate:"required"`
+	To   string   `json:"to"`
 	From []string `json:"from" validate:"required"`
 }
 

internal/command/admin/layer/query.go

@@ -2,6 +2,7 @@ package layer
 
 import (
 	"os"
+	"slices"
 
 	"forge.cadoles.com/cadoles/bouncer/internal/client"
 	"forge.cadoles.com/cadoles/bouncer/internal/command/admin/apierr"
@@ -52,14 +53,16 @@ func QueryCommand() *cli.Command {
 
 			client := client.New(baseFlags.ServerURL, client.WithToken(token))
 
-			proxies, err := client.QueryLayer(ctx.Context, proxyName, options...)
+			layers, err := client.QueryLayer(ctx.Context, proxyName, options...)
 			if err != nil {
 				return errors.WithStack(apierr.Wrap(err))
 			}
 
+			slices.SortFunc(layers, sortLayerssByWeight)
+
 			hints := layerHeaderHints(baseFlags.OutputMode)
 
-			if err := format.Write(baseFlags.Format, os.Stdout, hints, clientFlag.AsAnySlice(proxies)...); err != nil {
+			if err := format.Write(baseFlags.Format, os.Stdout, hints, clientFlag.AsAnySlice(layers)...); err != nil {
 				return errors.WithStack(err)
 			}
 
@@ -67,3 +70,13 @@ func QueryCommand() *cli.Command {
 		},
 	}
 }
+
+func sortLayerssByWeight(a *store.LayerHeader, b *store.LayerHeader) int {
+	if a.Weight < b.Weight {
+		return 1
+	}
+	if a.Weight > b.Weight {
+		return -1
+	}
+	return 0
+}

internal/command/admin/proxy/create.go

@@ -19,7 +19,7 @@ func CreateCommand() *cli.Command {
 		Name:  "create",
 		Usage: "Create proxy",
 		Flags: proxyFlag.WithProxyFlags(
-			flag.ProxyTo(true),
+			flag.ProxyTo(),
 			flag.ProxyFrom(),
 		),
 		Action: func(ctx *cli.Context) error {

internal/command/admin/proxy/flag/flag.go

@@ -30,12 +30,11 @@ func ProxyName() cli.Flag {
 
 const KeyProxyTo = "proxy-to"
 
-func ProxyTo(required bool) cli.Flag {
+func ProxyTo() cli.Flag {
 	return &cli.StringFlag{
-		Name:     KeyProxyTo,
-		Usage:    "Set `PROXY_TO` as proxy's destination url",
-		Value:    "",
-		Required: required,
+		Name:  KeyProxyTo,
+		Usage: "Set `PROXY_TO` as proxy's destination url",
+		Value: "",
 	}
 }
 

internal/command/admin/proxy/query.go

@@ -2,6 +2,7 @@ package proxy
 
 import (
 	"os"
+	"slices"
 
 	"forge.cadoles.com/cadoles/bouncer/internal/client"
 	"forge.cadoles.com/cadoles/bouncer/internal/command/admin/apierr"
@@ -51,6 +52,8 @@ func QueryCommand() *cli.Command {
 				return errors.WithStack(apierr.Wrap(err))
 			}
 
+			slices.SortFunc(proxies, sortProxiesByWeight)
+
 			hints := proxyHeaderHints(baseFlags.OutputMode)
 
 			if err := format.Write(baseFlags.Format, os.Stdout, hints, clientFlag.AsAnySlice(proxies)...); err != nil {
@@ -61,3 +64,13 @@ func QueryCommand() *cli.Command {
 		},
 	}
 }
+
+func sortProxiesByWeight(a *store.ProxyHeader, b *store.ProxyHeader) int {
+	if a.Weight < b.Weight {
+		return 1
+	}
+	if a.Weight > b.Weight {
+		return -1
+	}
+	return 0
+}

internal/command/admin/proxy/update.go

@@ -19,7 +19,7 @@ func UpdateCommand() *cli.Command {
 		Name:  "update",
 		Usage: "Update proxy",
 		Flags: proxyFlag.WithProxyFlags(
-			flag.ProxyTo(false),
+			flag.ProxyTo(),
 			flag.ProxyFrom(),
 			flag.ProxyEnabled(),
 			flag.ProxyWeight(),

internal/config/proxy_server.go

@@ -7,22 +7,26 @@ import (
 )
 
 type ProxyServerConfig struct {
-	HTTP      HTTPConfig      `yaml:"http"`
-	Metrics   MetricsConfig   `yaml:"metrics"`
-	Transport TransportConfig `yaml:"transport"`
-	Dial      DialConfig      `yaml:"dial"`
-	Sentry    SentryConfig    `yaml:"sentry"`
-	Cache     CacheConfig     `yaml:"cache"`
+	Debug     InterpolatedBool `yaml:"debug"`
+	HTTP      HTTPConfig       `yaml:"http"`
+	Metrics   MetricsConfig    `yaml:"metrics"`
+	Transport TransportConfig  `yaml:"transport"`
+	Dial      DialConfig       `yaml:"dial"`
+	Sentry    SentryConfig     `yaml:"sentry"`
+	Cache     CacheConfig      `yaml:"cache"`
+	Templates TemplatesConfig  `yaml:"templates"`
 }
 
 func NewDefaultProxyServerConfig() ProxyServerConfig {
 	return ProxyServerConfig{
+		Debug:     false,
 		HTTP:      NewHTTPConfig("0.0.0.0", 8080),
 		Metrics:   NewDefaultMetricsConfig(),
 		Transport: NewDefaultTransportConfig(),
 		Dial:      NewDefaultDialConfig(),
 		Sentry:    NewDefaultSentryConfig(),
 		Cache:     NewDefaultCacheConfig(),
+		Templates: NewDefaultTemplatesConfig(),
 	}
 }
 
@@ -115,3 +119,13 @@ func NewDefaultCacheConfig() CacheConfig {
 		TTL: *NewInterpolatedDuration(time.Second * 30),
 	}
 }
+
+type TemplatesConfig struct {
+	Dir InterpolatedString `yaml:"dir"`
+}
+
+func NewDefaultTemplatesConfig() TemplatesConfig {
+	return TemplatesConfig{
+		Dir: "./templates",
+	}
+}

internal/proxy/director/context.go

@@ -34,19 +34,6 @@ func OriginalURL(ctx context.Context) (*url.URL, error) {
 	return url, nil
 }
 
-func withProxy(ctx context.Context, proxy *store.Proxy) context.Context {
-	return context.WithValue(ctx, contextKeyProxy, proxy)
-}
-
-func ctxProxy(ctx context.Context) (*store.Proxy, error) {
-	proxy, err := ctxValue[*store.Proxy](ctx, contextKeyProxy)
-	if err != nil {
-		return nil, errors.WithStack(err)
-	}
-
-	return proxy, nil
-}
-
 func withLayers(ctx context.Context, layers []*store.Layer) context.Context {
 	return context.WithValue(ctx, contextKeyLayers, layers)
 }

internal/proxy/director/director.go

@@ -36,15 +36,15 @@ func (d *Director) rewriteRequest(r *http.Request) (*http.Request, error) {
 	ctx = withOriginalURL(ctx, url)
 	ctx = logger.With(ctx, logger.F("url", url.String()))
 
-	var match *store.Proxy
+	layers := make([]*store.Layer, 0)
 
-MAIN:
 	for _, p := range proxies {
 		for _, from := range p.From {
 			logger.Debug(
 				ctx, "matching request with proxy's from",
 				logger.F("from", from),
 			)
+
 			if matches := wildcard.Match(url.String(), from); !matches {
 				continue
 			}
@@ -54,38 +54,41 @@ MAIN:
 				logger.F("from", from),
 			)
 
-			match = p
-			break MAIN
+			ctx = logger.With(ctx,
+				logger.F("proxy", p.Name),
+				logger.F("host", r.Host),
+				logger.F("remoteAddr", r.RemoteAddr),
+			)
+
+			metricProxyRequestsTotal.With(prometheus.Labels{metricLabelProxy: string(p.Name)}).Add(1)
+
+			proxyLayers, err := d.getLayers(ctx, p.Name)
+			if err != nil {
+				return r, errors.WithStack(err)
+			}
+
+			layers = append(layers, proxyLayers...)
+
+			if p.To == "" {
+				continue
+			}
+
+			toURL, err := url.Parse(p.To)
+			if err != nil {
+				return r, errors.WithStack(err)
+			}
+
+			r.URL.Host = toURL.Host
+			r.URL.Scheme = toURL.Scheme
+			r.URL.Path = toURL.JoinPath(r.URL.Path).Path
+
+			ctx = withLayers(ctx, layers)
+			r = r.WithContext(ctx)
+
+			return r, nil
 		}
 	}
 
-	if match == nil {
-		return r, nil
-	}
-
-	toURL, err := url.Parse(match.To)
-	if err != nil {
-		return r, errors.WithStack(err)
-	}
-
-	r.URL.Host = toURL.Host
-	r.URL.Scheme = toURL.Scheme
-
-	ctx = logger.With(ctx,
-		logger.F("proxy", match.Name),
-		logger.F("host", r.Host),
-		logger.F("remoteAddr", r.RemoteAddr),
-	)
-
-	metricProxyRequestsTotal.With(prometheus.Labels{metricLabelProxy: string(match.Name)}).Add(1)
-
-	ctx = withProxy(ctx, match)
-
-	layers, err := d.getLayers(ctx, match.Name)
-	if err != nil {
-		return r, errors.WithStack(err)
-	}
-
 	ctx = withLayers(ctx, layers)
 	r = r.WithContext(ctx)
 

internal/proxy/director/layer/authn/oidc/authenticator.go

@@ -42,7 +42,7 @@ func (a *Authenticator) PreAuthentication(w http.ResponseWriter, r *http.Request
 		return errors.WithStack(err)
 	}
 
-	sess, err := a.store.Get(r, a.getCookieName(options.Cookie.Name, layer.Name))
+	sess, err := a.store.Get(r, a.getCookieName(options.Cookie.Name, layer.Proxy, layer.Name))
 	if err != nil {
 		logger.Error(ctx, "could not retrieve session", logger.E(errors.WithStack(err)))
 	}
@@ -121,7 +121,7 @@ func (a *Authenticator) Authenticate(w http.ResponseWriter, r *http.Request, lay
 		return nil, errors.WithStack(err)
 	}
 
-	sess, err := a.store.Get(r, a.getCookieName(options.Cookie.Name, layer.Name))
+	sess, err := a.store.Get(r, a.getCookieName(options.Cookie.Name, layer.Proxy, layer.Name))
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
@@ -401,8 +401,14 @@ func (a *Authenticator) getClient(options *LayerOptions, redirectURL string) (*C
 	return client, nil
 }
 
-func (a *Authenticator) getCookieName(cookieName string, layerName store.LayerName) string {
-	return fmt.Sprintf("%s_%s", cookieName, layerName)
+const defaultCookieNamePrefix = "_bouncer_authn_oidc"
+
+func (a *Authenticator) getCookieName(cookieName string, proxyName store.ProxyName, layerName store.LayerName) string {
+	if cookieName != "" {
+		return cookieName
+	}
+
+	return strings.ToLower(fmt.Sprintf("%s_%s_%s", defaultCookieNamePrefix, proxyName, layerName))
 }
 
 var (

internal/proxy/director/layer/authn/oidc/layer_options.go

@@ -8,8 +8,6 @@ import (
 	"github.com/pkg/errors"
 )
 
-const defaultCookieName = "_bouncer_authn_oidc"
-
 type LayerOptions struct {
 	authn.LayerOptions
 	OIDC   OIDCOptions   `mapstructure:"oidc"`
@@ -57,7 +55,7 @@ func fromStoreOptions(storeOptions store.LayerOptions) (*LayerOptions, error) {
 			Scopes:                 []string{"openid"},
 		},
 		Cookie: CookieOptions{
-			Name:     defaultCookieName,
+			Name:     "",
 			Path:     "/",
 			HTTPOnly: true,
 			MaxAge:   time.Hour,

internal/proxy/director/layer/authn/rules.go

@@ -1,70 +1,16 @@
 package authn
 
 import (
-	"fmt"
 	"net/http"
-	"strconv"
-	"strings"
-	"time"
 
-	"forge.cadoles.com/Cadoles/go-proxy/wildcard"
+	"forge.cadoles.com/cadoles/bouncer/internal/rule"
+	ruleHTTP "forge.cadoles.com/cadoles/bouncer/internal/rule/http"
 	"github.com/expr-lang/expr"
 	"github.com/pkg/errors"
 )
 
-func (l *Layer) getHeaderRuleOptions(r *http.Request) []expr.Option {
-	options := make([]expr.Option, 0)
-
-	setHeader := expr.Function(
-		"set_header",
-		func(params ...any) (any, error) {
-			name := params[0].(string)
-			rawValue := params[1]
-
-			var value string
-			switch v := rawValue.(type) {
-			case []string:
-				value = strings.Join(v, ",")
-			case time.Time:
-				value = strconv.FormatInt(v.UTC().Unix(), 10)
-			case time.Duration:
-				value = strconv.FormatInt(int64(v.Seconds()), 10)
-			default:
-				value = fmt.Sprintf("%v", rawValue)
-			}
-
-			r.Header.Set(name, value)
-
-			return true, nil
-		},
-		new(func(string, string) bool),
-	)
-
-	options = append(options, setHeader)
-
-	delHeaders := expr.Function(
-		"del_headers",
-		func(params ...any) (any, error) {
-			pattern := params[0].(string)
-			deleted := false
-
-			for key := range r.Header {
-				if !wildcard.Match(key, pattern) {
-					continue
-				}
-
-				r.Header.Del(key)
-				deleted = true
-			}
-
-			return deleted, nil
-		},
-		new(func(string) bool),
-	)
-
-	options = append(options, delHeaders)
-
-	return options
+type Env struct {
+	User *User `expr:"user"`
 }
 
 func (l *Layer) applyRules(r *http.Request, options *LayerOptions, user *User) error {
@@ -73,38 +19,39 @@ func (l *Layer) applyRules(r *http.Request, options *LayerOptions, user *User) e
 		return nil
 	}
 
-	env := map[string]any{
-		"user": user,
+	engine, err := rule.NewEngine[*Env](
+		rule.WithRules(options.Rules...),
+		rule.WithExpr(getAuthnAPI()...),
+		ruleHTTP.WithRequestFuncs(r),
+	)
+	if err != nil {
+		return errors.WithStack(err)
 	}
 
-	rulesOptions := l.getHeaderRuleOptions(r)
+	env := &Env{
+		User: user,
+	}
 
-	var ruleErr error
-	forbidden := expr.Function(
-		"forbidden",
-		func(params ...any) (any, error) {
-			ruleErr = errors.WithStack(ErrForbidden)
-			return true, nil
-		},
-		new(func() bool),
-	)
-
-	rulesOptions = append(rulesOptions, forbidden)
-
-	for i, r := range rules {
-		program, err := expr.Compile(r, rulesOptions...)
-		if err != nil {
-			return errors.Wrapf(err, "could not compile rule #%d", i)
-		}
-
-		if _, err := expr.Run(program, env); err != nil {
-			return errors.Wrapf(err, "could not execute rule #%d", i)
-		}
-
-		if ruleErr != nil {
-			return errors.WithStack(ruleErr)
-		}
+	if _, err := engine.Apply(env); err != nil {
+		return errors.WithStack(err)
 	}
 
 	return nil
 }
+
+func getAuthnAPI() []expr.Option {
+	options := make([]expr.Option, 0)
+
+	// forbidden() allows the layer to hijack the current request and return a 403 Forbidden HTTP status
+	forbidden := expr.Function(
+		"forbidden",
+		func(params ...any) (any, error) {
+			return true, errors.WithStack(ErrForbidden)
+		},
+		new(func() bool),
+	)
+
+	options = append(options, forbidden)
+
+	return options
+}

internal/proxy/director/layer/rewriter/layer-options.json

@@ -0,0 +1,38 @@
+{
+    "type": "object",
+    "properties": {
+        "rules": {
+            "title": "Règles appliquées aux requêtes/réponses transitant par le proxy",
+            "type": "object",
+            "properties": {
+                "request": {
+                    "title": "Règles appliquées aux requêtes transitant par le proxy",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "response": {
+                    "title": "Règles appliquées aux réponses transitant par le proxy",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "additionalProperties": false
+        },
+        "matchURLs": {
+            "title": "Liste de filtrage des URLs sur lesquelles le layer est actif",
+            "description": "Par exemple, si vous souhaitez limiter votre layer à l'ensemble d'une section '`/blog`' d'un site, vous pouvez déclarer la valeur `['*/blog*']`. Les autres URLs du site ne seront pas affectées par ce layer.",
+            "default": [
+                "*"
+            ],
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        }
+    },
+    "additionalProperties": false
+}

internal/proxy/director/layer/rewriter/layer.go

@@ -0,0 +1,84 @@
+package rewriter
+
+import (
+	"net/http"
+
+	proxy "forge.cadoles.com/Cadoles/go-proxy"
+	"forge.cadoles.com/Cadoles/go-proxy/wildcard"
+	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director"
+	"forge.cadoles.com/cadoles/bouncer/internal/store"
+	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
+)
+
+const LayerType store.LayerType = "rewriter"
+
+type Layer struct{}
+
+func (l *Layer) LayerType() store.LayerType {
+	return LayerType
+}
+
+func (l *Layer) Middleware(layer *store.Layer) proxy.Middleware {
+	return func(next http.Handler) http.Handler {
+		fn := func(w http.ResponseWriter, r *http.Request) {
+			ctx := r.Context()
+
+			options, err := fromStoreOptions(layer.Options)
+			if err != nil {
+				logger.Error(ctx, "could not parse layer options", logger.E(errors.WithStack(err)))
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
+				return
+			}
+
+			matches := wildcard.MatchAny(r.URL.String(), options.MatchURLs...)
+			if !matches {
+				next.ServeHTTP(w, r)
+
+				return
+			}
+
+			if err := l.applyRequestRules(r, options); err != nil {
+				logger.Error(ctx, "could not apply request rules", logger.E(errors.WithStack(err)))
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		}
+
+		return http.HandlerFunc(fn)
+	}
+}
+
+// ResponseTransformer implements director.ResponseTransformerLayer.
+func (l *Layer) ResponseTransformer(layer *store.Layer) proxy.ResponseTransformer {
+	return func(r *http.Response) error {
+		options, err := fromStoreOptions(layer.Options)
+		if err != nil {
+			return errors.WithStack(err)
+		}
+
+		matches := wildcard.MatchAny(r.Request.URL.String(), options.MatchURLs...)
+		if !matches {
+			return nil
+		}
+
+		if err := l.applyResponseRules(r, options); err != nil {
+			return errors.WithStack(err)
+		}
+
+		return nil
+	}
+}
+
+func New() *Layer {
+	return &Layer{}
+}
+
+var (
+	_ director.MiddlewareLayer          = &Layer{}
+	_ director.ResponseTransformerLayer = &Layer{}
+)

internal/proxy/director/layer/rewriter/layer_options.go

@@ -0,0 +1,56 @@
+package rewriter
+
+import (
+	"forge.cadoles.com/cadoles/bouncer/internal/store"
+	"github.com/mitchellh/mapstructure"
+	"github.com/pkg/errors"
+)
+
+type LayerOptions struct {
+	MatchURLs []string `mapstructure:"matchURLs"`
+	Rules     Rules    `mapstructure:"rules"`
+}
+
+type Rules struct {
+	Request  []string `mapstructure:"request"`
+	Response []string `mapstructure:"response"`
+}
+
+func DefaultLayerOptions() LayerOptions {
+	return LayerOptions{
+		MatchURLs: []string{"*"},
+		Rules: Rules{
+			Request:  []string{},
+			Response: []string{},
+		},
+	}
+
+}
+
+func fromStoreOptions(storeOptions store.LayerOptions) (*LayerOptions, error) {
+	layerOptions := DefaultLayerOptions()
+
+	if err := FromStoreOptions(storeOptions, &layerOptions); err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	return &layerOptions, nil
+}
+
+func FromStoreOptions(storeOptions store.LayerOptions, dest any) error {
+	config := mapstructure.DecoderConfig{
+		Result:     dest,
+		ZeroFields: true,
+	}
+
+	decoder, err := mapstructure.NewDecoder(&config)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	if err := decoder.Decode(storeOptions); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}

internal/proxy/director/layer/rewriter/rules.go

@@ -0,0 +1,133 @@
+package rewriter
+
+import (
+	"net/http"
+
+	"forge.cadoles.com/cadoles/bouncer/internal/rule"
+	ruleHTTP "forge.cadoles.com/cadoles/bouncer/internal/rule/http"
+	"github.com/pkg/errors"
+)
+
+type RequestEnv struct {
+	Request RequestInfo `expr:"request"`
+}
+
+type RequestInfo struct {
+	Method           string              `expr:"method"`
+	URL              string              `expr:"url"`
+	Proto            string              `expr:"proto"`
+	ProtoMajor       int                 `expr:"protoMajor"`
+	ProtoMinor       int                 `expr:"protoMinor"`
+	Header           map[string][]string `expr:"header"`
+	ContentLength    int64               `expr:"contentLength"`
+	TransferEncoding []string            `expr:"transferEncoding"`
+	Host             string              `expr:"host"`
+	Trailer          map[string][]string `expr:"trailer"`
+	RemoteAddr       string              `expr:"remoteAddr"`
+	RequestURI       string              `expr:"requestUri"`
+}
+
+func (l *Layer) applyRequestRules(r *http.Request, options *LayerOptions) error {
+	rules := options.Rules.Request
+	if len(rules) == 0 {
+		return nil
+	}
+
+	engine, err := rule.NewEngine[*RequestEnv](
+		ruleHTTP.WithRequestFuncs(r),
+		rule.WithRules(options.Rules.Request...),
+	)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	env := &RequestEnv{
+		Request: RequestInfo{
+			Method:           r.Method,
+			URL:              r.URL.String(),
+			Proto:            r.Proto,
+			ProtoMajor:       r.ProtoMajor,
+			ProtoMinor:       r.ProtoMinor,
+			Header:           r.Header,
+			ContentLength:    r.ContentLength,
+			TransferEncoding: r.TransferEncoding,
+			Host:             r.Host,
+			Trailer:          r.Trailer,
+			RemoteAddr:       r.RemoteAddr,
+			RequestURI:       r.RequestURI,
+		},
+	}
+
+	if _, err := engine.Apply(env); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}
+
+type ResponseEnv struct {
+	Request  RequestInfo  `expr:"request"`
+	Response ResponseInfo `expr:"response"`
+}
+
+type ResponseInfo struct {
+	Status           string              `expr:"status"`
+	StatusCode       int                 `expr:"statusCode"`
+	Proto            string              `expr:"proto"`
+	ProtoMajor       int                 `expr:"protoMajor"`
+	ProtoMinor       int                 `expr:"protoMinor"`
+	Header           map[string][]string `expr:"header"`
+	ContentLength    int64               `expr:"contentLength"`
+	TransferEncoding []string            `expr:"transferEncoding"`
+	Uncompressed     bool                `expr:"uncompressed"`
+	Trailer          map[string][]string `expr:"trailer"`
+}
+
+func (l *Layer) applyResponseRules(r *http.Response, options *LayerOptions) error {
+	rules := options.Rules.Request
+	if len(rules) == 0 {
+		return nil
+	}
+
+	engine, err := rule.NewEngine[*ResponseEnv](
+		rule.WithRules(options.Rules.Response...),
+		ruleHTTP.WithResponseFuncs(r),
+	)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	env := &ResponseEnv{
+		Request: RequestInfo{
+			Method:           r.Request.Method,
+			URL:              r.Request.URL.String(),
+			Proto:            r.Request.Proto,
+			ProtoMajor:       r.Request.ProtoMajor,
+			ProtoMinor:       r.Request.ProtoMinor,
+			Header:           r.Request.Header,
+			ContentLength:    r.Request.ContentLength,
+			TransferEncoding: r.Request.TransferEncoding,
+			Host:             r.Request.Host,
+			Trailer:          r.Request.Trailer,
+			RemoteAddr:       r.Request.RemoteAddr,
+			RequestURI:       r.Request.RequestURI,
+		},
+		Response: ResponseInfo{
+			Proto:            r.Proto,
+			ProtoMajor:       r.ProtoMajor,
+			ProtoMinor:       r.ProtoMinor,
+			Header:           r.Header,
+			ContentLength:    r.ContentLength,
+			TransferEncoding: r.TransferEncoding,
+			Trailer:          r.Trailer,
+			Status:           r.Status,
+			StatusCode:       r.StatusCode,
+		},
+	}
+
+	if _, err := engine.Apply(env); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}

internal/proxy/director/layer/rewriter/schema.go

@@ -0,0 +1,8 @@
+package rewriter
+
+import (
+	_ "embed"
+)
+
+//go:embed layer-options.json
+var RawLayerOptionsSchema []byte

internal/proxy/server.go

@@ -3,11 +3,14 @@ package proxy
 import (
 	"context"
 	"fmt"
+	"html/template"
 	"log"
 	"net"
 	"net/http"
 	"net/http/httputil"
 	"net/url"
+	"path/filepath"
+	"strconv"
 	"time"
 
 	"forge.cadoles.com/Cadoles/go-proxy"
@@ -17,6 +20,8 @@ import (
 	"forge.cadoles.com/cadoles/bouncer/internal/config"
 	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director"
 	"forge.cadoles.com/cadoles/bouncer/internal/store"
+
+	"github.com/Masterminds/sprig/v3"
 	"github.com/getsentry/sentry-go"
 	sentryhttp "github.com/getsentry/sentry-go/http"
 	"github.com/go-chi/chi/v5"
@@ -152,6 +157,7 @@ func (s *Server) run(parentCtx context.Context, addrs chan net.Addr, errs chan e
 				director.ResponseTransformer(),
 			),
 			proxy.WithReverseProxyFactory(s.createReverseProxy),
+			proxy.WithDefaultHandler(http.HandlerFunc(s.handleDefault)),
 		)
 
 		r.Handle("/*", handler)
@@ -180,18 +186,83 @@ func (s *Server) createReverseProxy(ctx context.Context, target *url.URL) *httpu
 	httpTransport.DialContext = dialer.DialContext
 
 	reverseProxy.Transport = httpTransport
-	reverseProxy.ErrorHandler = s.errorHandler
+	reverseProxy.ErrorHandler = s.handleError
 
 	return reverseProxy
 }
 
-func (s *Server) errorHandler(w http.ResponseWriter, r *http.Request, err error) {
+func (s *Server) handleDefault(w http.ResponseWriter, r *http.Request) {
+	err := errors.Errorf("no proxy target found")
+
+	logger.Error(r.Context(), "proxy error", logger.E(err))
+	sentry.CaptureException(err)
+
+	s.renderErrorPage(w, r, err, http.StatusBadGateway, http.StatusText(http.StatusBadGateway))
+}
+
+func (s *Server) handleError(w http.ResponseWriter, r *http.Request, err error) {
 	err = errors.WithStack(err)
 
 	logger.Error(r.Context(), "proxy error", logger.E(err))
 	sentry.CaptureException(err)
 
-	http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+	s.renderErrorPage(w, r, err, http.StatusBadGateway, http.StatusText(http.StatusBadGateway))
+}
+
+func (s *Server) renderErrorPage(w http.ResponseWriter, r *http.Request, err error, statusCode int, status string) {
+	templateData := struct {
+		StatusCode int
+		Status     string
+		Err        error
+		Debug      bool
+	}{
+		Debug:      bool(s.serverConfig.Debug),
+		StatusCode: statusCode,
+		Status:     status,
+		Err:        err,
+	}
+
+	w.WriteHeader(statusCode)
+	s.renderPage(w, r, "error", strconv.FormatInt(int64(statusCode), 10), templateData)
+}
+
+func (s *Server) renderPage(w http.ResponseWriter, r *http.Request, page string, block string, templateData any) {
+	ctx := r.Context()
+
+	templatesConf := s.serverConfig.Templates
+
+	pattern := filepath.Join(string(templatesConf.Dir), page+".gohtml")
+
+	logger.Info(ctx, "loading proxy templates", logger.F("pattern", pattern))
+
+	tmpl, err := template.New("").Funcs(sprig.FuncMap()).ParseGlob(pattern)
+	if err != nil {
+		logger.Error(ctx, "could not load proxy templates", logger.E(errors.WithStack(err)))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
+		return
+	}
+
+	w.Header().Add("Cache-Control", "no-cache")
+
+	blockTmpl := tmpl.Lookup(block)
+	if blockTmpl == nil {
+		blockTmpl = tmpl.Lookup("default")
+	}
+
+	if blockTmpl == nil {
+		logger.Error(ctx, "could not find template block nor default one", logger.F("block", block))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
+		return
+	}
+
+	if err := blockTmpl.Execute(w, templateData); err != nil {
+		logger.Error(ctx, "could not render proxy page", logger.E(errors.WithStack(err)))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
+		return
+	}
 }
 
 func NewServer(funcs ...OptionFunc) *Server {

internal/rule/engine.go

@@ -0,0 +1,44 @@
+package rule
+
+import (
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
+	"github.com/pkg/errors"
+)
+
+type Engine[E any] struct {
+	rules []*vm.Program
+}
+
+func (e *Engine[E]) Apply(env E) ([]any, error) {
+	results := make([]any, 0, len(e.rules))
+	for i, r := range e.rules {
+		result, err := expr.Run(r, env)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not run rule #%d", i)
+		}
+
+		results = append(results, result)
+	}
+
+	return results, nil
+}
+
+func NewEngine[E any](funcs ...OptionFunc) (*Engine[E], error) {
+	opts := NewOptions(funcs...)
+
+	engine := &Engine[E]{
+		rules: make([]*vm.Program, 0, len(opts.Rules)),
+	}
+
+	for i, r := range opts.Rules {
+		program, err := expr.Compile(r, opts.Expr...)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not compile rule #%d", i)
+		}
+
+		engine.rules = append(engine.rules, program)
+	}
+
+	return engine, nil
+}

internal/rule/http/option.go

@@ -0,0 +1,42 @@
+package http
+
+import (
+	"net/http"
+
+	"forge.cadoles.com/cadoles/bouncer/internal/rule"
+	"github.com/expr-lang/expr"
+)
+
+func WithRequestFuncs(r *http.Request) rule.OptionFunc {
+	return func(opts *rule.Options) {
+		funcs := []expr.Option{
+			setRequestURL(r),
+			setRequestHeaderFunc(r),
+			addRequestHeaderFunc(r),
+			delRequestHeadersFunc(r),
+			setRequestHostFunc(r),
+		}
+
+		if len(opts.Expr) == 0 {
+			opts.Expr = make([]expr.Option, 0)
+		}
+
+		opts.Expr = append(opts.Expr, funcs...)
+	}
+}
+
+func WithResponseFuncs(r *http.Response) rule.OptionFunc {
+	return func(opts *rule.Options) {
+		funcs := []expr.Option{
+			setResponseHeaderFunc(r),
+			addResponseHeaderFunc(r),
+			delResponseHeadersFunc(r),
+		}
+
+		if len(opts.Expr) == 0 {
+			opts.Expr = make([]expr.Option, 0)
+		}
+
+		opts.Expr = append(opts.Expr, funcs...)
+	}
+}

internal/rule/http/request.go

@@ -0,0 +1,122 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"forge.cadoles.com/Cadoles/go-proxy/wildcard"
+	"github.com/expr-lang/expr"
+	"github.com/pkg/errors"
+)
+
+func setRequestHostFunc(r *http.Request) expr.Option {
+	return expr.Function(
+		"set_host",
+		func(params ...any) (any, error) {
+			host := params[0].(string)
+			r.Host = host
+
+			return true, nil
+		},
+		new(func(string) bool),
+	)
+}
+
+func setRequestURL(r *http.Request) expr.Option {
+	return expr.Function(
+		"set_url",
+		func(params ...any) (any, error) {
+			rawURL := params[0].(string)
+
+			url, err := url.Parse(rawURL)
+			if err != nil {
+				return false, errors.WithStack(err)
+			}
+
+			r.URL = url
+
+			return true, nil
+		},
+		new(func(string) bool),
+	)
+}
+
+func addRequestHeaderFunc(r *http.Request) expr.Option {
+	return expr.Function(
+		"add_header",
+		func(params ...any) (any, error) {
+			name := params[0].(string)
+			rawValue := params[1]
+
+			var value string
+			switch v := rawValue.(type) {
+			case []string:
+				value = strings.Join(v, ",")
+			case time.Time:
+				value = strconv.FormatInt(v.UTC().Unix(), 10)
+			case time.Duration:
+				value = strconv.FormatInt(int64(v.Seconds()), 10)
+			default:
+				value = fmt.Sprintf("%v", rawValue)
+			}
+
+			r.Header.Add(name, value)
+
+			return true, nil
+		},
+		new(func(string, string) bool),
+	)
+}
+
+func setRequestHeaderFunc(r *http.Request) expr.Option {
+	return expr.Function(
+		"set_header",
+		func(params ...any) (any, error) {
+			name := params[0].(string)
+			rawValue := params[1]
+
+			var value string
+			switch v := rawValue.(type) {
+			case []string:
+				value = strings.Join(v, ",")
+			case time.Time:
+				value = strconv.FormatInt(v.UTC().Unix(), 10)
+			case time.Duration:
+				value = strconv.FormatInt(int64(v.Seconds()), 10)
+			default:
+				value = fmt.Sprintf("%v", rawValue)
+			}
+
+			r.Header.Set(name, value)
+
+			return true, nil
+		},
+		new(func(string, string) bool),
+	)
+}
+
+func delRequestHeadersFunc(r *http.Request) expr.Option {
+	return expr.Function(
+		"del_headers",
+		func(params ...any) (any, error) {
+			pattern := params[0].(string)
+			deleted := false
+
+			for key := range r.Header {
+				if !wildcard.Match(key, pattern) {
+					continue
+				}
+
+				r.Header.Del(key)
+				deleted = true
+			}
+
+			return deleted, nil
+		},
+		new(func(string) bool),
+	)
+}

internal/rule/http/response.go

@@ -0,0 +1,88 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"forge.cadoles.com/Cadoles/go-proxy/wildcard"
+	"github.com/expr-lang/expr"
+)
+
+func addResponseHeaderFunc(r *http.Response) expr.Option {
+	return expr.Function(
+		"add_header",
+		func(params ...any) (any, error) {
+			name := params[0].(string)
+			rawValue := params[1]
+
+			var value string
+			switch v := rawValue.(type) {
+			case []string:
+				value = strings.Join(v, ",")
+			case time.Time:
+				value = strconv.FormatInt(v.UTC().Unix(), 10)
+			case time.Duration:
+				value = strconv.FormatInt(int64(v.Seconds()), 10)
+			default:
+				value = fmt.Sprintf("%v", rawValue)
+			}
+
+			r.Header.Add(name, value)
+
+			return true, nil
+		},
+		new(func(string, string) bool),
+	)
+}
+
+func setResponseHeaderFunc(r *http.Response) expr.Option {
+	return expr.Function(
+		"set_header",
+		func(params ...any) (any, error) {
+			name := params[0].(string)
+			rawValue := params[1]
+
+			var value string
+			switch v := rawValue.(type) {
+			case []string:
+				value = strings.Join(v, ",")
+			case time.Time:
+				value = strconv.FormatInt(v.UTC().Unix(), 10)
+			case time.Duration:
+				value = strconv.FormatInt(int64(v.Seconds()), 10)
+			default:
+				value = fmt.Sprintf("%v", rawValue)
+			}
+
+			r.Header.Set(name, value)
+
+			return true, nil
+		},
+		new(func(string, string) bool),
+	)
+}
+
+func delResponseHeadersFunc(r *http.Response) expr.Option {
+	return expr.Function(
+		"del_headers",
+		func(params ...any) (any, error) {
+			pattern := params[0].(string)
+			deleted := false
+
+			for key := range r.Header {
+				if !wildcard.Match(key, pattern) {
+					continue
+				}
+
+				r.Header.Del(key)
+				deleted = true
+			}
+
+			return deleted, nil
+		},
+		new(func(string) bool),
+	)
+}

internal/rule/options.go

@@ -0,0 +1,35 @@
+package rule
+
+import "github.com/expr-lang/expr"
+
+type Options struct {
+	Rules []string
+	Expr  []expr.Option
+}
+
+type OptionFunc func(opts *Options)
+
+func NewOptions(funcs ...OptionFunc) *Options {
+	opts := &Options{
+		Expr:  make([]expr.Option, 0),
+		Rules: make([]string, 0),
+	}
+
+	for _, fn := range funcs {
+		fn(opts)
+	}
+
+	return opts
+}
+
+func WithRules(rules ...string) OptionFunc {
+	return func(opts *Options) {
+		opts.Rules = rules
+	}
+}
+
+func WithExpr(options ...expr.Option) OptionFunc {
+	return func(opts *Options) {
+		opts.Expr = options
+	}
+}

internal/setup/rewriter_layer.go

@@ -0,0 +1,15 @@
+package setup
+
+import (
+	"forge.cadoles.com/cadoles/bouncer/internal/config"
+	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director"
+	"forge.cadoles.com/cadoles/bouncer/internal/proxy/director/layer/rewriter"
+)
+
+func init() {
+	RegisterLayer(rewriter.LayerType, setupRewriterLayer, rewriter.RawLayerOptionsSchema)
+}
+
+func setupRewriterLayer(conf *config.Config) (director.Layer, error) {
+	return rewriter.New(), nil
+}

misc/bootstrap.d/dummy.yml

@@ -19,7 +19,8 @@ layers:
   #       clientId: my-client-id
   #       clientSecret: my-client-id
   #       issuerURL: https://forge.cadoles.com/
-  #       postLogoutRedirectURL: http://localhost:8080
+  #       postLogoutRedirectURLs:
+  #         - http://localhost:8080
   #       scopes: ["profile", "openid", "email"]
   #       authParams:
   #         acr_values: "eidas2"

misc/images/bouncer/Dockerfile

@@ -1,49 +0,0 @@
-FROM golang:1.20 AS BUILD
-
-RUN apt-get update \
-    && apt-get install -y make
-
-ARG YQ_VERSION=4.34.1
-
-RUN mkdir -p /usr/local/bin \
-    && wget -O /usr/local/bin/yq https://github.com/mikefarah/yq/releases/download/v${YQ_VERSION}/yq_linux_amd64 \
-    && chmod +x /usr/local/bin/yq
-
-COPY . /src
-
-WORKDIR /src
-
-RUN make GORELEASER_ARGS='build --rm-dist --single-target --snapshot' goreleaser
-
-# Patch config
-RUN /src/dist/bouncer_linux_amd64_v1/bouncer -c '' config dump > /src/dist/bouncer_linux_amd64_v1/config.yml \
-    && yq -i '.layers.queue.templateDir = "/usr/share/bouncer/layers/queue/templates"' /src/dist/bouncer_linux_amd64_v1/config.yml \
-    && yq -i '.admin.auth.privateKey = "/etc/bouncer/admin-key.json"' /src/dist/bouncer_linux_amd64_v1/config.yml \
-    && yq -i '.redis.adresses = ["redis:6379"]' /src/dist/bouncer_linux_amd64_v1/config.yml
-
-FROM alpine:3.18 AS RUNTIME
-
-ARG DUMB_INIT_VERSION=1.2.5
-
-RUN apk add --no-cache ca-certificates
-
-RUN mkdir -p /usr/local/bin \
-    && wget -O /usr/local/bin/dumb-init https://github.com/Yelp/dumb-init/releases/download/v${DUMB_INIT_VERSION}/dumb-init_${DUMB_INIT_VERSION}_x86_64 \
-    && chmod +x /usr/local/bin/dumb-init
-
-ENTRYPOINT ["/usr/local/bin/dumb-init", "--"]
-
-RUN mkdir -p /usr/local/bin /usr/share/bouncer/bin /etc/bouncer
-
-COPY --from=BUILD /src/dist/bouncer_linux_amd64_v1/bouncer /usr/share/bouncer/bin/bouncer
-COPY --from=BUILD /src/layers /usr/share/bouncer/layers
-COPY --from=BUILD /src/dist/bouncer_linux_amd64_v1/config.yml /etc/bouncer/config.yml
-
-RUN ln -s /usr/share/bouncer/bin/bouncer /usr/local/bin/bouncer
-
-EXPOSE 8080
-EXPOSE 8081
-
-ENV BOUNCER_CONFIG=/etc/bouncer/config.yml
-
-CMD ["bouncer"]

misc/packaging/common/config.yml

@@ -70,6 +70,12 @@ admin:
 
 # Configuration du service "proxy"
 proxy:
+  # Activer/désactiver le mode debug (affichage ou non des messages d'erreur)
+  debug: false
+  # Configuration des templates utilisés par le proxy
+  templates:
+    # Répertoire contenant les templates
+    dir: /etc/bouncer/templates
   http:
     # Hôte d'écoute du service,
     # 0.0.0.0 pour écouter sur toutes les interfaces

templates/error.gohtml

@@ -0,0 +1,96 @@
+{{ define "default" }}
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    {{ $title := print .StatusCode " - " .Status }}
+    <title>{{ $title }}</title>
+    <style>
+      html {
+        box-sizing: border-box;
+        font-size: 16px;
+      }
+
+      *,
+      *:before,
+      *:after {
+        box-sizing: inherit;
+      }
+
+      body,
+      h1,
+      h2,
+      h3,
+      h4,
+      h5,
+      h6,
+      p,
+      ol,
+      ul {
+        margin: 0;
+        padding: 0;
+        font-weight: normal;
+      }
+
+      html,
+      body {
+        width: 100%;
+        height: 100%;
+        font-family: Arial, Helvetica, sans-serif;
+        background-color: #ffe4e4;
+      }
+
+      #container {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        height: 100%;
+        flex-direction: column;
+      }
+
+      #card {
+        padding: 1.5em 1em;
+        border: 1px solid #d90202;
+        background-color: #feb0b0;
+        border-radius: 5px;
+        box-shadow: 2px 2px #cccccc1c;
+        color: #810000 !important;
+      }
+
+      .title {
+        margin-bottom: 1.2em;
+      }
+
+      p {
+        margin-bottom: 0.5em;
+      }
+
+      code,
+      pre {
+        font-family: monospace;
+      }
+
+      .footer {
+        font-size: 0.7em;
+        margin-top: 2em;
+        text-align: right;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="container">
+      <div id="card">
+        <h2 class="title">{{ $title }}</h2>
+        {{ if .Debug }}
+        <pre>{{ .Err }}</pre>
+        {{ end }}
+        <p class="footer">
+          Propulsé par
+          <a href="https://forge.cadoles.com/Cadoles/bouncer">Bouncer</a>.
+        </p>
+      </div>
+    </div>
+  </body>
+</html>
+{{ end }}