mirror of
https://github.com/netbirdio/netbird.git
synced 2026-05-31 21:19:55 +00:00
7aebdd69dd
Adds a new "private" service mode for the reverse proxy: services reachable exclusively over the embedded WireGuard tunnel, gated by per-peer group membership instead of operator auth schemes. Wire contract - ProxyMapping.private (field 13): the proxy MUST call ValidateTunnelPeer and fail closed; operator schemes are bypassed. - ProxyCapabilities.private (4) + supports_private_service (5): capability gate. Management never streams private mappings to proxies that don't claim the capability; the broadcast path applies the same filter via filterMappingsForProxy. - ValidateTunnelPeer RPC: resolves an inbound tunnel IP to a peer, checks the peer's groups against service.AccessGroups, and mints a session JWT on success. checkPeerGroupAccess fails closed when a private service has empty AccessGroups. - ValidateSession/ValidateTunnelPeer responses now carry peer_group_ids + peer_group_names so the proxy can authorise policy-aware middlewares without an extra management round-trip. - ProxyInboundListener + SendStatusUpdate.inbound_listener: per-account inbound listener state surfaced to dashboards. - PathTargetOptions.direct_upstream (11): bypass the embedded NetBird client and dial the target via the proxy host's network stack for upstreams reachable without WireGuard. Data model - Service.Private (bool) + Service.AccessGroups ([]string, JSON- serialised). Validate() rejects bearer auth on private services. Copy() deep-copies AccessGroups. pgx getServices loads the columns. - DomainConfig.Private threaded into the proxy auth middleware. Request handler routes private services through forwardWithTunnelPeer and returns 403 on validation failure. - Account-level SynthesizePrivateServiceZones (synthetic DNS) and injectPrivateServicePolicies (synthetic ACL) gate on len(svc.AccessGroups) > 0. Proxy - /netbird proxy --private (embedded mode) flag; Config.Private in proxy/lifecycle.go. - Per-account inbound listener (proxy/inbound.go) binding HTTP/HTTPS on the embedded NetBird client's WireGuard tunnel netstack. - proxy/internal/auth/tunnel_cache: ValidateTunnelPeer response cache with single-flight de-duplication and per-account eviction. - Local peerstore short-circuit: when the inbound IP isn't in the account roster, deny fast without an RPC. - proxy/server.go reports SupportsPrivateService=true and redacts the full ProxyMapping JSON from info logs (auth_token + header-auth hashed values now only at debug level). Identity forwarding - ValidateSessionJWT returns user_id, email, method, groups, group_names. sessionkey.Claims carries Email + Groups + GroupNames so the proxy can stamp identity onto upstream requests without an extra management round-trip on every cookie-bearing request. - CapturedData carries userEmail / userGroups / userGroupNames; the proxy stamps X-NetBird-User and X-NetBird-Groups on r.Out from the authenticated identity (strips client-supplied values first to prevent spoofing). - AccessLog.UserGroups: access-log enrichment captures the user's group memberships at write time so the dashboard can render group context without reverse-resolving stale memberships. OpenAPI/dashboard surface - ReverseProxyService gains private + access_groups; ReverseProxyCluster gains private + supports_private. ReverseProxyTarget target_type enum gains "cluster". ServiceTargetOptions gains direct_upstream. ProxyAccessLog gains user_groups.
91 lines
3.1 KiB
Go
91 lines
3.1 KiB
Go
//go:build integration
|
|
|
|
package rest_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/netbirdio/netbird/shared/management/client/rest"
|
|
"github.com/netbirdio/netbird/shared/management/http/api"
|
|
"github.com/netbirdio/netbird/shared/management/http/util"
|
|
)
|
|
|
|
func boolPtr(b bool) *bool { return &b }
|
|
|
|
var testCluster = api.ProxyCluster{
|
|
Id: "cluster-1",
|
|
Address: "proxy.netbird.local",
|
|
Type: "shared",
|
|
Online: true,
|
|
ConnectedProxies: 2,
|
|
SupportsCustomPorts: boolPtr(true),
|
|
RequireSubdomain: boolPtr(false),
|
|
SupportsCrowdsec: boolPtr(false),
|
|
Private: boolPtr(true),
|
|
}
|
|
|
|
func TestReverseProxyClusters_List_200(t *testing.T) {
|
|
withMockClient(func(c *rest.Client, mux *http.ServeMux) {
|
|
mux.HandleFunc("/api/reverse-proxies/clusters", func(w http.ResponseWriter, r *http.Request) {
|
|
assert.Equal(t, "GET", r.Method, "List must use GET")
|
|
retBytes, _ := json.Marshal([]api.ProxyCluster{testCluster})
|
|
_, err := w.Write(retBytes)
|
|
require.NoError(t, err)
|
|
})
|
|
ret, err := c.ReverseProxyClusters.List(context.Background())
|
|
require.NoError(t, err)
|
|
require.Len(t, ret, 1)
|
|
assert.Equal(t, testCluster.Id, ret[0].Id)
|
|
assert.Equal(t, testCluster.Address, ret[0].Address)
|
|
require.NotNil(t, ret[0].Private, "private capability must round-trip through the client")
|
|
assert.True(t, *ret[0].Private, "private capability must reflect the server value")
|
|
})
|
|
}
|
|
|
|
func TestReverseProxyClusters_List_Err(t *testing.T) {
|
|
withMockClient(func(c *rest.Client, mux *http.ServeMux) {
|
|
mux.HandleFunc("/api/reverse-proxies/clusters", func(w http.ResponseWriter, r *http.Request) {
|
|
retBytes, _ := json.Marshal(util.ErrorResponse{Message: "No", Code: 500})
|
|
w.WriteHeader(500)
|
|
_, err := w.Write(retBytes)
|
|
require.NoError(t, err)
|
|
})
|
|
ret, err := c.ReverseProxyClusters.List(context.Background())
|
|
assert.Error(t, err)
|
|
assert.Empty(t, ret)
|
|
})
|
|
}
|
|
|
|
func TestReverseProxyClusters_Delete_200(t *testing.T) {
|
|
withMockClient(func(c *rest.Client, mux *http.ServeMux) {
|
|
// PathEscape on "proxy.netbird.local" leaves it intact; the route mux
|
|
// matches the unescaped form. Sanity-check both the method and that
|
|
// path-escaping doesn't double-encode the dotted address.
|
|
mux.HandleFunc("/api/reverse-proxies/clusters/proxy.netbird.local", func(w http.ResponseWriter, r *http.Request) {
|
|
assert.Equal(t, "DELETE", r.Method, "Delete must use DELETE")
|
|
w.WriteHeader(200)
|
|
})
|
|
err := c.ReverseProxyClusters.Delete(context.Background(), "proxy.netbird.local")
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
|
|
func TestReverseProxyClusters_Delete_Err(t *testing.T) {
|
|
withMockClient(func(c *rest.Client, mux *http.ServeMux) {
|
|
mux.HandleFunc("/api/reverse-proxies/clusters/proxy.netbird.local", func(w http.ResponseWriter, r *http.Request) {
|
|
retBytes, _ := json.Marshal(util.ErrorResponse{Message: "Not found", Code: 404})
|
|
w.WriteHeader(404)
|
|
_, err := w.Write(retBytes)
|
|
require.NoError(t, err)
|
|
})
|
|
err := c.ReverseProxyClusters.Delete(context.Background(), "proxy.netbird.local")
|
|
assert.Error(t, err)
|
|
})
|
|
}
|