chore: add http debug env in default environment file

Reviewed-on: #29

.env.dist

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

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/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
+    | TYPE      | OPTIONS                           |
-
+    +-----------+-----------------------------------+
-   USAGE:
+    | basicauth | {"type":"object","properties":... |
-   bouncer admin layer create [command options] [arguments...]
+    +-----------+-----------------------------------+
-
-   OPTIONS:
-   --layer-type LAYER_TYPE        Set LAYER_TYPE as layer's type (available: [basicauth queue])
-   [...]
    ```
 
    Comme vous devriez le voir nous pouvons désormais créer des layers de type `basicauth`.

internal/proxy/director/director.go

@@ -70,6 +70,7 @@ MAIN:
 
 	r.URL.Host = toURL.Host
 	r.URL.Scheme = toURL.Scheme
+	r.URL.Path = toURL.JoinPath(r.URL.Path).Path
 
 	ctx = logger.With(ctx,
 		logger.F("proxy", match.Name),
@@ -77,6 +78,11 @@ MAIN:
 		logger.F("remoteAddr", r.RemoteAddr),
 	)
 
+	logger.Debug(
+		ctx, "rewritten url",
+		logger.F("rewrittenURL", r.URL.String()),
+	)
+
 	metricProxyRequestsTotal.With(prometheus.Labels{metricLabelProxy: string(match.Name)}).Add(1)
 
 	ctx = withProxy(ctx, match)

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 {
+type Env struct {
-	options := make([]expr.Option, 0)
+	User *User `expr:"user"`
-
-	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
 }
 
 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{
+	engine, err := rule.NewEngine[*Env](
-		"user": user,
+		rule.WithRules(options.Rules...),
-	}
+		rule.WithExpr(getAuthnAPI()...),
-
+		ruleHTTP.WithRequestFuncs(r),
-	rulesOptions := l.getHeaderRuleOptions(r)
-
-	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)
+		return errors.WithStack(err)
 	}
 
-		if _, err := expr.Run(program, env); err != nil {
+	env := &Env{
-			return errors.Wrapf(err, "could not execute rule #%d", i)
+		User: user,
 	}
 
-		if ruleErr != nil {
+	if _, err := engine.Apply(env); err != nil {
-			return errors.WithStack(ruleErr)
+		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

@@ -191,7 +191,7 @@ func (s *Server) errorHandler(w http.ResponseWriter, r *http.Request, err error)
 	logger.Error(r.Context(), "proxy error", logger.E(err))
 	sentry.CaptureException(err)
 
-	http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+	http.Error(w, http.StatusText(http.StatusBadGateway), http.StatusBadGateway)
 }
 
 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"